# OpenTable + Resy Scraper (`maximedupre/opentable-resy-scraper`) Actor

Scrape OpenTable and Resy restaurant data by city, cuisine, search query, URL, or slug. Export ratings, prices, photos, source links, and Resy availability.

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

## Pricing

from $2.70 / 1,000 restaurants

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

### 🍽️ OpenTable + Resy scraper for restaurant data

OpenTable + Resy Scraper collects public restaurant data from [OpenTable](https://www.opentable.com/) and [Resy](https://resy.com/) in one Apify Actor. Search by city, cuisine, or keyword, or paste direct venue URLs and slugs when you already know the restaurants you want to export.

Use this OpenTable + Resy scraper when you need restaurant names, source IDs, profile URLs, cuisines, prices, ratings, review counts, neighborhoods, photos, and source context in one dataset. Direct Resy venue runs also check availability for the selected date and party size, so you can monitor reservation context without opening each restaurant page by hand.

For a quick first run, keep the prefilled New York Italian search with **OpenTable + Resy** selected and **Restaurant limit** set to `150`. The Actor will return one row per restaurant and interleave OpenTable and Resy results under the same total limit.

### ✅ What this Actor does

- Searches OpenTable, Resy, or both platforms in one run.
- Searches by city, cuisine, keyword, reservation date, and party size.
- Accepts direct OpenTable and Resy venue URLs or slugs.
- Saves one dataset row per restaurant profile.
- Extracts source IDs, source URLs, names, cuisines, price bands, ratings, review counts, neighborhoods, photos, and scrape timestamps when the source returns them.
- Adds OpenTable-specific fields such as recent reservation counts, feature flags, and private dining flags when available.
- Adds Resy-specific fields such as venue type, description, contact data, and direct venue availability snapshots when available.
- Lets you filter saved rows by country, price range, and minimum rating when those fields are available.
- Works with Apify dataset exports, API clients, schedules, webhooks, and integrations.
- Creates restaurant charge events only for saved restaurant profiles.

This Actor focuses on public restaurant data from OpenTable and Resy. It does not place reservations, book tables, scrape private account data, ask for cookies, or use user-provided OpenTable or Resy API keys.

### 📦 Data you can extract

Each saved restaurant row can include:

- `platform`: `opentable` or `resy`
- `entityId`, `sourceId`, `sourceSlug`, and `sourceUrl`
- `name` and `recordType`
- `primaryCuisine` and `cuisines`
- `price.label`, `price.bandId`, and `price.currencySymbol`
- `rating.average`, `rating.reviewCount`, and `rating.source`
- `address`, `coordinates`, and `neighborhood`
- `contact.phone` and `contact.website` when available
- `media.coverImageUrl` and `media.imageUrls`
- `openTable.recentReservationCount`, `openTable.features`, and `openTable.privateDining`
- `resy.venueType`, `resy.description`, and `resy.availability`
- `source.targetType`, `source.inputTarget`, `source.query`, `source.city`, `source.cuisine`, and `source.rank`
- `scrapedAt`

OpenTable and Resy do not expose every field for every venue. Empty or missing source fields are left out instead of being guessed.

### 🔎 How to run it

1. Choose **Restaurant platform**: OpenTable, Resy, or both.
2. Choose **Target type**:
   - **Search by city or cuisine** for discovery runs.
   - **Direct venue URLs or slugs** for known restaurants.
3. For search runs, set **City**, **Cuisine**, and optional **Search query**.
4. For direct runs, paste OpenTable or Resy venue URLs or slugs.
5. Set **Restaurant limit** to cap the total saved rows.
6. Run the Actor and export the dataset as JSON, CSV, Excel, or through the Apify API.

The default input is built for a small first run. Once the output shape fits your workflow, raise the row limit, schedule repeat runs, or call the Actor from your own app.

### 🧾 Input options

| Field | What it does |
| --- | --- |
| `platform` | Selects OpenTable, Resy, or both platforms. |
| `targetType` | Chooses search mode or direct venue mode. |
| `city` | Sets the city for search runs and location context. |
| `query` | Adds an optional restaurant name, neighborhood, or dining keyword. |
| `cuisine` | Searches by dining style such as `italian`, `sushi`, or `steakhouse`. |
| `restaurantTargets` | Accepts OpenTable or Resy venue URLs and slugs for direct runs. |
| `country` | Keeps rows from a selected country when the source provides country data. |
| `priceRange` | Keeps rows in a selected price band. |
| `minRating` | Keeps rows with this rating or higher when ratings are available. |
| `availabilityDate` | Sets the date for Resy direct venue availability checks. |
| `partySize` | Sets the guest count for reservation and availability context. |
| `reservationDate` | Sets the OpenTable search date context. |
| `maxItems` | Caps the total restaurant rows saved by the run. |

### 🧪 Example input

```json
{
	"platform": "both",
	"targetType": "search",
	"city": "New York",
	"cuisine": "italian",
	"partySize": 2,
	"reservationDate": "2026-07-15",
	"availabilityDate": "2026-07-15",
	"maxItems": 150
}
````

For direct venue runs:

```json
{
	"platform": "both",
	"targetType": "direct",
	"restaurantTargets": [
		"https://www.opentable.com/r/sofias-of-little-italy-new-york",
		"https://resy.com/cities/ny/venues/carbone"
	],
	"city": "New York",
	"partySize": 2,
	"availabilityDate": "2026-07-15",
	"maxItems": 2
}
```

### 📄 Example output

```json
{
	"platform": "resy",
	"recordType": "restaurant",
	"entityId": "resy:6194",
	"sourceId": 6194,
	"sourceSlug": "carbone",
	"sourceUrl": "https://resy.com/cities/ny/venues/carbone",
	"name": "Carbone",
	"address": {
		"line1": "181 Thompson Street",
		"city": "New York",
		"state": "NY",
		"postalCode": "10012",
		"country": "United States",
		"countryCode": "US",
		"formatted": "181 Thompson Street, New York, NY, 10012, United States"
	},
	"resy": {
		"availability": {
			"day": "2026-07-15",
			"partySize": 2,
			"slotCount": 0,
			"slots": []
		}
	},
	"source": {
		"targetType": "direct",
		"inputTarget": "https://resy.com/cities/ny/venues/carbone",
		"city": "New York",
		"rank": 1
	},
	"scrapedAt": "2026-06-12T19:34:00.000Z"
}
```

The exact fields depend on what OpenTable or Resy returns for each restaurant.

### 💳 Pricing

This Actor uses pay-per-event pricing. You pay a small one-time Actor start charge and one **Restaurant** event for each restaurant profile saved to the dataset.

The restaurant event is the main pricing unit. Runs that find no matching restaurants finish cleanly and do not create restaurant events.

### ⚠️ Limits and caveats

- Resy availability is checked for direct Resy venue runs. Search rows focus on restaurant discovery data.
- OpenTable direct URLs are resolved through public search data. Very stale or removed URLs may not resolve.
- OpenTable and Resy can return different fields for different restaurants, cities, and dates.
- Availability changes quickly. Treat saved Resy slots as a point-in-time snapshot.
- The Actor does not book reservations, hold tables, bypass source restrictions, or scrape private account data.

### ❓ FAQ

#### 🔁 Can I scrape OpenTable and Resy in the same run?

Yes. Choose `both` for `platform`. Search runs interleave OpenTable and Resy rows under the same `maxItems` cap.

#### 🔐 Do I need OpenTable or Resy cookies?

No. The Actor is built for public restaurant data and does not ask for user cookies, passwords, or API keys.

#### 🗓️ Can I check Resy availability?

Yes, for direct Resy venue targets. Add a Resy venue URL or slug, set `availabilityDate` and `partySize`, and the row will include a Resy availability snapshot when the source returns it.

#### 🧩 Why are some fields missing from a row?

OpenTable and Resy do not return the same data for every restaurant. The Actor saves fields that the source provides and avoids filling gaps with guessed data.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

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

### 🔗 Other actors

- [Google Maps Shared List Scraper ↗](https://apify.com/maximedupre/google-maps-shared-list-scraper) - Export saved places from public Google Maps shared lists.
- [Yellow Pages Scraper ↗](https://apify.com/maximedupre/yellowpages-scraper) - Collect business listings by keyword, location, search URL, or listing URL.
- [DoorDash Reviews Scraper ↗](https://apify.com/maximedupre/doordash-reviews-scraper) - Extract public DoorDash review previews from restaurant store pages.
- [Facebook Reviews Scraper ↗](https://apify.com/maximedupre/facebook-reviews-scraper) - Export public Facebook Page recommendations for local business research.
- [Business Address Scraper ↗](https://apify.com/maximedupre/business-address-scraper) - Find physical business addresses published on company websites.

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

# Actor input Schema

## `platform` (type: `string`):

Choose OpenTable, Resy, or both restaurant platforms for this run.

## `targetType` (type: `string`):

Use search targets for city and cuisine discovery, or direct targets for known venue URLs and slugs.

## `city` (type: `string`):

City to search, such as New York, London, Los Angeles, or Paris.

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

Optional restaurant name, neighborhood, or dining keyword to search.

## `cuisine` (type: `string`):

Cuisine or dining style to search. Pick a suggestion or enter your own.

## `restaurantTargets` (type: `array`):

Add OpenTable or Resy venue URLs or slugs, such as https://www.opentable.com/r/cecconis-dumbo-brooklyn or https://resy.com/cities/ny/venues/carbone.

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

Limit saved restaurants to a country when the source provides country data.

## `priceRange` (type: `string`):

Save restaurants in the selected source price band.

## `minRating` (type: `integer`):

Save restaurants with this rating or higher when the source provides ratings.

## `availabilityDate` (type: `string`):

Date for Resy availability checks on direct Resy venues.

## `partySize` (type: `integer`):

Number of guests for reservation and availability context.

## `reservationDate` (type: `string`):

Date used for OpenTable search availability context.

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

Maximum restaurant rows to save across the whole run.

## Actor input object example

```json
{
  "platform": "both",
  "targetType": "search",
  "city": "New York",
  "query": "",
  "cuisine": "italian",
  "restaurantTargets": [
    "https://www.opentable.com/r/sofias-of-little-italy-new-york",
    "https://resy.com/cities/ny/venues/carbone"
  ],
  "country": "",
  "priceRange": "",
  "availabilityDate": "2026-07-15",
  "partySize": 2,
  "reservationDate": "2026-07-15",
  "maxItems": 150
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset with OpenTable and Resy restaurant names, ratings, prices, addresses, photos, source URLs, and availability snapshots.

# 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 = {
    "platform": "both",
    "targetType": "search",
    "city": "New York",
    "cuisine": "italian",
    "restaurantTargets": [
        "https://www.opentable.com/r/sofias-of-little-italy-new-york",
        "https://resy.com/cities/ny/venues/carbone"
    ],
    "availabilityDate": "2026-07-15",
    "partySize": 2,
    "reservationDate": "2026-07-15",
    "maxItems": 150
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/opentable-resy-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 = {
    "platform": "both",
    "targetType": "search",
    "city": "New York",
    "cuisine": "italian",
    "restaurantTargets": [
        "https://www.opentable.com/r/sofias-of-little-italy-new-york",
        "https://resy.com/cities/ny/venues/carbone",
    ],
    "availabilityDate": "2026-07-15",
    "partySize": 2,
    "reservationDate": "2026-07-15",
    "maxItems": 150,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/opentable-resy-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 '{
  "platform": "both",
  "targetType": "search",
  "city": "New York",
  "cuisine": "italian",
  "restaurantTargets": [
    "https://www.opentable.com/r/sofias-of-little-italy-new-york",
    "https://resy.com/cities/ny/venues/carbone"
  ],
  "availabilityDate": "2026-07-15",
  "partySize": 2,
  "reservationDate": "2026-07-15",
  "maxItems": 150
}' |
apify call maximedupre/opentable-resy-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenTable + Resy Scraper",
        "description": "Scrape OpenTable and Resy restaurant data by city, cuisine, search query, URL, or slug. Export ratings, prices, photos, source links, and Resy availability.",
        "version": "0.1",
        "x-build-id": "asBUnvPmo7HnArfYZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~opentable-resy-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-opentable-resy-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~opentable-resy-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-opentable-resy-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~opentable-resy-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-opentable-resy-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "platform",
                    "targetType",
                    "maxItems"
                ],
                "properties": {
                    "platform": {
                        "title": "Restaurant platform",
                        "enum": [
                            "both",
                            "opentable",
                            "resy"
                        ],
                        "type": "string",
                        "description": "Choose OpenTable, Resy, or both restaurant platforms for this run.",
                        "default": "both"
                    },
                    "targetType": {
                        "title": "Target type",
                        "enum": [
                            "search",
                            "direct"
                        ],
                        "type": "string",
                        "description": "Use search targets for city and cuisine discovery, or direct targets for known venue URLs and slugs.",
                        "default": "search"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City to search, such as New York, London, Los Angeles, or Paris.",
                        "default": "New York"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Optional restaurant name, neighborhood, or dining keyword to search.",
                        "default": ""
                    },
                    "cuisine": {
                        "title": "Cuisine",
                        "type": "string",
                        "description": "Cuisine or dining style to search. Pick a suggestion or enter your own."
                    },
                    "restaurantTargets": {
                        "title": "Venue URLs or slugs",
                        "type": "array",
                        "description": "Add OpenTable or Resy venue URLs or slugs, such as https://www.opentable.com/r/cecconis-dumbo-brooklyn or https://resy.com/cities/ny/venues/carbone.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "",
                            "US",
                            "CA",
                            "GB",
                            "IE",
                            "FR",
                            "DE",
                            "IT",
                            "ES",
                            "PT",
                            "NL",
                            "AT",
                            "CH",
                            "BE",
                            "DK",
                            "SE",
                            "NO",
                            "FI",
                            "AU",
                            "NZ",
                            "JP",
                            "HK",
                            "SG",
                            "AE",
                            "MX",
                            "AR",
                            "BR"
                        ],
                        "type": "string",
                        "description": "Limit saved restaurants to a country when the source provides country data.",
                        "default": ""
                    },
                    "priceRange": {
                        "title": "Price range",
                        "enum": [
                            "",
                            "$",
                            "$$",
                            "$$$",
                            "$$$$"
                        ],
                        "type": "string",
                        "description": "Save restaurants in the selected source price band.",
                        "default": ""
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Save restaurants with this rating or higher when the source provides ratings."
                    },
                    "availabilityDate": {
                        "title": "Availability date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Date for Resy availability checks on direct Resy venues."
                    },
                    "partySize": {
                        "title": "Party size",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "Number of guests for reservation and availability context.",
                        "default": 2
                    },
                    "reservationDate": {
                        "title": "OpenTable search date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Date used for OpenTable search availability context."
                    },
                    "maxItems": {
                        "title": "Restaurant limit",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum restaurant rows to save across the whole run.",
                        "default": 150
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
