# OpenTable Reviews Scraper – Restaurants, Ratings & Diner Data (`abotapi/opentable-reviews-scraper`) Actor

Scrape full OpenTable.com restaurant reviews by keyword, area, or restaurant profile URLs. Collect every available review with text, ratings, diner profile data, tags, photos, restaurant metadata, cuisines, neighborhood, and profile links in structured rows.

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

## Pricing

from $1.00 / 1,000 review scrapeds

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 Reviews Scraper

Scrape full OpenTable restaurant reviews by keyword and area or by pasted restaurant profile URLs. The actor collects every available review for each restaurant and returns structured rows with review text, ratings, diner profile data, review tags, review photos, restaurant metadata, cuisines, neighborhood, and profile links.

### What You Get

Each dataset row is one OpenTable review. A keyword search collects the full review history for every restaurant it discovers around your coordinates; URL mode collects every review for each restaurant link you paste.

```json
{
  "reviewId": "OT-4528-2110885052-140154862704",
  "reviewText": "Great place for dinner! The bar is beautiful and casual while the dining space is really nice!",
  "ratingOverall": 5,
  "ratingFood": 5,
  "ratingService": 5,
  "ratingAmbience": 5,
  "ratingValue": 5,
  "ratingNoise": "MODERATE",
  "reviewType": "OPENTABLEVERIFIED",
  "submittedDateTime": "2026-06-10T16:02:39Z",
  "dinedDateTime": "2026-06-09T18:45:00-04:00",
  "dinedDate": "2026-06-09",
  "reviewHelpfulUp": 0,
  "reviewHelpfulDown": 0,
  "reviewHelpfulScore": 0,
  "restaurantReplyText": null,
  "reviewerName": "Lynn",
  "reviewerLocation": "New York City",
  "reviewerApprovedReviewCount": 3,
  "reviewPhotoUrls": ["https://resizer.otstatic.com/v4/photos/94818492-1?width=160&height=160"],
  "reviewPhotoCount": 1,
  "restaurantId": 4528,
  "restaurantName": "Nobu Downtown",
  "restaurantUrl": "https://www.opentable.com/r/nobu-downtown-new-york",
  "restaurantPrimaryCuisine": "Japanese",
  "restaurantRating": 4.7,
  "restaurantTotalReviewCount": 5397
}
````

### Input Modes

#### Keyword Search

Use keyword search when you want discovery by restaurant, cuisine, or dining phrase around a latitude and longitude.

```json
{
  "mode": "search",
  "keywords": ["sushi", "steakhouse"],
  "location": "New York",
  "maxItems": 20
}
```

`location` accepts a city, neighborhood, or address (for example `New York`, `Chelsea Manhattan`, or `90210`) and is resolved to map coordinates automatically. For precise control you can instead set `latitude` and `longitude`, which override `location` when both are provided.

#### Restaurant URLs

Use URL mode when you already have OpenTable restaurant profile links.

```json
{
  "mode": "url",
  "startUrls": [
    { "url": "https://www.opentable.com/r/yakiniku-shodai-san-francisco" }
  ],
  "maxItems": 10
}
```

### Filters

Filters apply to both input modes:

| Field | Type | Description |
| --- | --- | --- |
| `minOverallRating` | number | Keep reviews with this overall rating or higher. |
| `minFoodRating` | number | Keep reviews with this food rating or higher. |
| `minServiceRating` | number | Keep reviews with this service rating or higher. |
| `minAmbienceRating` | number | Keep reviews with this ambience rating or higher. |
| `minValueRating` | number | Keep reviews with this value rating or higher. |
| `cuisines` | array | Keep restaurants matching at least one cuisine value. |
| `neighborhoods` | array | Keep restaurants matching at least one neighborhood value. |
| `fromDinedDate` | string | Keep reviews dined on or after this YYYY-MM-DD date. |
| `toDinedDate` | string | Keep reviews dined on or before this YYYY-MM-DD date. |
| `vipOnly` | boolean | Keep reviews from VIP reviewers only. |
| `requireReviewPhotos` | boolean | Keep reviews with diner photos only. |

### Output Controls

| Field | Type | Description |
| --- | --- | --- |
| `maxItems` | integer | Primary cap on total review rows saved across the run. |
| `maxReviewsPerRestaurant` | integer | Optional cap per restaurant. Leave empty to collect every review (bounded only by `maxItems`). |
| `maxRestaurants` | integer | Keyword search only. How many restaurants per keyword to collect reviews from. |
| `reviewSort` | string | Review order per restaurant: `highestRated` (default), `newest`, or `lowestRated`. |

### MCP Connectors

Use `mcpConnectors` to send selected results into connected apps through Apify integrations. Supported connector servers include Notion, Linear, Airtable, and Apify. Set `notionParentPageUrl` when exporting to Notion. `maxNotifyListings` controls how many rows are sent to each connector and does not change the dataset.

### Notes

OpenTable can return fewer rows than `maxItems` when the selected keyword, area, URLs, or filters match fewer current reviews. For URL mode, paste OpenTable restaurant profile links and the actor returns the matching restaurant's review where available.

# Actor input Schema

## `mode` (type: `string`):

Search mode discovers restaurants around the selected coordinates and collects their full review history. URL mode takes pasted restaurant profile links and collects every review for each one.

## `keywords` (type: `array`):

Restaurant, cuisine, or dining terms to search. Examples: sushi, steakhouse, rooftop, vegan.

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

City, neighborhood, or address to search around (keyword search mode). For example: New York, Chelsea Manhattan, or 90210. The actor resolves this to map coordinates automatically.

## `latitude` (type: `number`):

Optional. Exact latitude to search around. When both latitude and longitude are set they override Location.

## `longitude` (type: `number`):

Optional. Exact longitude to search around. When both latitude and longitude are set they override Location.

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

Paste OpenTable restaurant profile URLs such as https://www.opentable.com/r/yakiniku-shodai-san-francisco.

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

Maximum review rows to save across the whole run. The run can return fewer rows when OpenTable has fewer matching reviews.

## `maxReviewsPerRestaurant` (type: `integer`):

Optional cap on how many reviews to collect from each restaurant. Leave empty to collect every available review for each restaurant (bounded only by Max items).

## `maxRestaurants` (type: `integer`):

Keyword search only. How many restaurants around the coordinates to collect reviews from per keyword.

## `reviewSort` (type: `string`):

Order of reviews returned for each restaurant.

## `minOverallRating` (type: `number`):

Only keep reviews with at least this overall review rating.

## `minFoodRating` (type: `number`):

Only keep reviews with at least this food rating.

## `minServiceRating` (type: `number`):

Only keep reviews with at least this service rating.

## `minAmbienceRating` (type: `number`):

Only keep reviews with at least this ambience rating.

## `minValueRating` (type: `number`):

Only keep reviews with at least this value rating.

## `cuisines` (type: `array`):

Only keep restaurants whose primary or secondary cuisine contains at least one value.

## `neighborhoods` (type: `array`):

Only keep restaurants whose neighborhood contains at least one value.

## `fromDinedDate` (type: `string`):

Only keep reviews with a dined date on or after this YYYY-MM-DD date.

## `toDinedDate` (type: `string`):

Only keep reviews with a dined date on or before this YYYY-MM-DD date.

## `vipOnly` (type: `boolean`):

Only keep reviews where OpenTable marks the reviewer as VIP.

## `requireReviewPhotos` (type: `boolean`):

Only keep reviews that include diner photos.

## `proxy` (type: `object`):

Connection routing for the run. The default works best for reaching OpenTable reliably; change it only if your account or environment requires another route.

## `mcpConnectors` (type: `array`):

Optionally send scraped review rows into connected apps via Model Context Protocol connectors. Authorize a connector under Apify > Settings > API & Integrations, then select it here. Supported: Notion, Linear, Airtable, and Apify.

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which review pages are created. Required for Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on how many review rows are written to each selected connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": [
    "sushi"
  ],
  "location": "New York",
  "startUrls": [
    {
      "url": "https://www.opentable.com/r/yakiniku-shodai-san-francisco"
    }
  ],
  "maxItems": 20,
  "maxRestaurants": 50,
  "reviewSort": "highestRated",
  "vipOnly": false,
  "requireReviewPhotos": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keywords": [
        "sushi"
    ],
    "location": "New York",
    "startUrls": [
        {
            "url": "https://www.opentable.com/r/yakiniku-shodai-san-francisco"
        }
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/opentable-reviews-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 = {
    "keywords": ["sushi"],
    "location": "New York",
    "startUrls": [{ "url": "https://www.opentable.com/r/yakiniku-shodai-san-francisco" }],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/opentable-reviews-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 '{
  "keywords": [
    "sushi"
  ],
  "location": "New York",
  "startUrls": [
    {
      "url": "https://www.opentable.com/r/yakiniku-shodai-san-francisco"
    }
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call abotapi/opentable-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenTable Reviews Scraper – Restaurants, Ratings & Diner Data",
        "description": "Scrape full OpenTable.com restaurant reviews by keyword, area, or restaurant profile URLs. Collect every available review with text, ratings, diner profile data, tags, photos, restaurant metadata, cuisines, neighborhood, and profile links in structured rows.",
        "version": "0.1",
        "x-build-id": "ZmScxLW3h4LJUmd6g"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~opentable-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-opentable-reviews-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/abotapi~opentable-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-opentable-reviews-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/abotapi~opentable-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-opentable-reviews-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Input mode",
                        "enum": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "Search mode discovers restaurants around the selected coordinates and collects their full review history. URL mode takes pasted restaurant profile links and collects every review for each one.",
                        "default": "search"
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Restaurant, cuisine, or dining terms to search. Examples: sushi, steakhouse, rooftop, vegan.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, neighborhood, or address to search around (keyword search mode). For example: New York, Chelsea Manhattan, or 90210. The actor resolves this to map coordinates automatically.",
                        "default": "New York"
                    },
                    "latitude": {
                        "title": "Latitude (advanced)",
                        "type": "number",
                        "description": "Optional. Exact latitude to search around. When both latitude and longitude are set they override Location."
                    },
                    "longitude": {
                        "title": "Longitude (advanced)",
                        "type": "number",
                        "description": "Optional. Exact longitude to search around. When both latitude and longitude are set they override Location."
                    },
                    "startUrls": {
                        "title": "OpenTable restaurant URLs",
                        "type": "array",
                        "description": "Paste OpenTable restaurant profile URLs such as https://www.opentable.com/r/yakiniku-shodai-san-francisco.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Maximum review rows to save across the whole run. The run can return fewer rows when OpenTable has fewer matching reviews.",
                        "default": 20
                    },
                    "maxReviewsPerRestaurant": {
                        "title": "Max reviews per restaurant",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Optional cap on how many reviews to collect from each restaurant. Leave empty to collect every available review for each restaurant (bounded only by Max items)."
                    },
                    "maxRestaurants": {
                        "title": "Max restaurants per keyword",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Keyword search only. How many restaurants around the coordinates to collect reviews from per keyword.",
                        "default": 50
                    },
                    "reviewSort": {
                        "title": "Review sort order",
                        "enum": [
                            "highestRated",
                            "newest",
                            "lowestRated"
                        ],
                        "type": "string",
                        "description": "Order of reviews returned for each restaurant.",
                        "default": "highestRated"
                    },
                    "minOverallRating": {
                        "title": "Minimum overall rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only keep reviews with at least this overall review rating."
                    },
                    "minFoodRating": {
                        "title": "Minimum food rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only keep reviews with at least this food rating."
                    },
                    "minServiceRating": {
                        "title": "Minimum service rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only keep reviews with at least this service rating."
                    },
                    "minAmbienceRating": {
                        "title": "Minimum ambience rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only keep reviews with at least this ambience rating."
                    },
                    "minValueRating": {
                        "title": "Minimum value rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only keep reviews with at least this value rating."
                    },
                    "cuisines": {
                        "title": "Cuisine filter",
                        "type": "array",
                        "description": "Only keep restaurants whose primary or secondary cuisine contains at least one value.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "neighborhoods": {
                        "title": "Neighborhood filter",
                        "type": "array",
                        "description": "Only keep restaurants whose neighborhood contains at least one value.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fromDinedDate": {
                        "title": "Dined from",
                        "type": "string",
                        "description": "Only keep reviews with a dined date on or after this YYYY-MM-DD date."
                    },
                    "toDinedDate": {
                        "title": "Dined to",
                        "type": "string",
                        "description": "Only keep reviews with a dined date on or before this YYYY-MM-DD date."
                    },
                    "vipOnly": {
                        "title": "VIP reviewers only",
                        "type": "boolean",
                        "description": "Only keep reviews where OpenTable marks the reviewer as VIP.",
                        "default": false
                    },
                    "requireReviewPhotos": {
                        "title": "Require review photos",
                        "type": "boolean",
                        "description": "Only keep reviews that include diner photos.",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Connection routing for the run. The default works best for reaching OpenTable reliably; change it only if your account or environment requires another route."
                    },
                    "mcpConnectors": {
                        "title": "Pipe results into your apps (optional)",
                        "type": "array",
                        "description": "Optionally send scraped review rows into connected apps via Model Context Protocol connectors. Authorize a connector under Apify > Settings > API & Integrations, then select it here. Supported: Notion, Linear, Airtable, and Apify."
                    },
                    "notionParentPageUrl": {
                        "title": "Notion parent page",
                        "type": "string",
                        "description": "URL or id of the Notion page under which review pages are created. Required for Notion export; ignored by other connectors."
                    },
                    "maxNotifyListings": {
                        "title": "Max reviews to export per connector",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on how many review rows are written to each selected connector per run. Does not affect the dataset.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
