# OpenTable Scraper — Reviews, Restaurants & Availability (`bovi/opentable-scraper`) Actor

Scrape OpenTable restaurants AND individual reviews (reviewer, overall + food/service/ambience sub-ratings, text, dined date, helpful votes), plus availability and listings. By city, cuisine, or URL. Two PPE events: per restaurant + per review.

- **URL**: https://apify.com/bovi/opentable-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Travel, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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.

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 Scraper — Reviews, Restaurants & Availability

Extract structured restaurant data **and individual diner reviews** from OpenTable, plus availability and listings. Works in two modes:

1. **City search** — give a city slug (`san-francisco`, `new-york`, `chicago`) and optional cuisine keyword; the actor returns up to N restaurants with full profile data.
2. **URL list** — supply a list of OpenTable restaurant profile URLs for targeted scraping.

#### Why this scraper is best-in-class

Most OpenTable scrapers give you *either* reviews *or* listings. This one gives you **all three in one run**:

- **Individual reviews** — reviewer, overall rating, **food / service / ambience / value sub-ratings**, noise level, full text, *dined* date vs *review* date, and helpful-vote counts. (Most competitors only return the review text and a single overall star — we return the full breakdown.)
- **Restaurant listings** — name, address, phone, cuisine, price band, geo, hours, aggregate rating + review count.
- **Availability & reservations** — reservation acceptance + slots.

Reviews are extracted from the **same page** as the restaurant record, so they add **no extra requests** and don't slow the run down.

---

### Output shape

Every run produces two kinds of rows, distinguished by `record_type`, and accessible via two dataset views (**Restaurants** and **Reviews**):

- `record_type: "restaurant"` — one row per restaurant. Also carries a nested `reviews[]` array and a `reviews_extracted` count, so you can consume reviews either as flat rows or nested.
- `record_type: "review"` — one flat row per individual review, linked to its parent via `restaurant_id` + `restaurant_name`.

---

### What you get per restaurant

| Field | Example |
|---|---|
| `name` | Thirsty Bear |
| `slug` | thirsty-bear-san-francisco |
| `url` | https://www.opentable.com/r/thirsty-bear-san-francisco |
| `description` | Full restaurant description text |
| `cuisine` | `["Spanish", "Tapas / Small Plates", "Brewery"]` |
| `cuisine_str` | Spanish, Tapas / Small Plates, Brewery |
| `price_range` | $30 and under |
| `rating` | 3.9 |
| `review_count` | 615 |
| `accepts_reservations` | false |
| `street_address` | 661 Howard St. |
| `city` | San Francisco |
| `state` | CA |
| `zip_code` | 94105 |
| `country` | United States |
| `address` | 661 Howard St., San Francisco, CA, 94105 |
| `latitude` | 37.78565 |
| `longitude` | -122.399734 |
| `phone` | +1 415-974-0905 |
| `opening_hours` | `["Monday 11:30am–10:00pm", ...]` |
| `menu_url` | https://www.opentable.com/... |
| `reviews_extracted` | 10 |
| `reviews` | nested array of review objects (see below) |
| `restaurant_id` | 2 |
| `scraped_at` | 2026-06-07T12:00:00Z |

---

### What you get per review

Each review is emitted both as a nested item inside the restaurant record and as its own flat row (`record_type: "review"`):

| Field | Example |
|---|---|
| `restaurant_id` | 2 |
| `restaurant_name` | Thirsty Bear |
| `restaurant_slug` | thirsty-bear-san-francisco |
| `review_id` | OT-2-1804022929-150018263055 |
| `reviewer_name` | JoeF |
| `reviewer_initials` | JF |
| `reviewer_metro` | San Francisco |
| `reviewer_review_count` | 12 |
| `overall_rating` | 5 |
| `food_rating` | 5 |
| `service_rating` | 5 |
| `ambience_rating` | 4 |
| `value_rating` | 5 |
| `noise_level` | MODERATE |
| `review_text` | Great craft beers. Tapas and paella were very good. |
| `dined_date` | 2018-05-25 |
| `review_date` | 2018-05-27 |
| `helpful_count` | 0 |
| `helpful_up` / `helpful_down` | 0 / 0 |
| `has_photos` | false |
| `party_size` | null* |
| `occasion` | ""* |
| `scraped_at` | 2026-06-07T12:00:00Z |

\* `party_size` and `occasion` are not exposed in OpenTable's public review payload; the columns are kept for a stable schema and returned empty.

> **Coverage note:** OpenTable embeds roughly the 10 most-recent reviews on each restaurant page. The scraper reads those in the same request used for the restaurant record (no extra cost). Set `maxReviewsPerRestaurant` to cap how many are returned (default 20 = all embedded). Set `includeReviews: false` to skip reviews entirely.

---

### Inputs

#### City search mode (most common)

```json
{
  "city": "san-francisco",
  "cuisine": "italian",
  "maxItems": 100,
  "includeReviews": true,
  "maxReviewsPerRestaurant": 20
}
````

- **`city`** — City slug matching OpenTable's URL format. Examples: `san-francisco`, `new-york`, `chicago`, `los-angeles`, `miami`, `seattle`, `boston`, `denver`, `austin`.
- **`cuisine`** — Optional filter keyword. Examples: `italian`, `sushi`, `french`, `mexican`, `thai`, `indian`, `american`.
- **`maxItems`** — Maximum number of restaurant records to return (default 10, max 5000).
- **`includeReviews`** — Also extract individual reviews (default `true`).
- **`maxReviewsPerRestaurant`** — Cap on reviews per restaurant (default 20; OpenTable embeds ~10 per page).

#### URL list mode

```json
{
  "restaurantUrls": [
    "https://www.opentable.com/r/thirsty-bear-san-francisco",
    "https://www.opentable.com/r/foreign-cinema-san-francisco"
  ]
}
```

Supply any list of OpenTable `/r/{slug}` URLs. The actor scrapes each one and returns the full record.

***

### How it works

OpenTable uses a behavioral JavaScript challenge. This actor uses a managed proxy layer to reliably access OpenTable pages without any setup on your end.

**Restaurant discovery (city search mode):**
OpenTable publishes a public sitemap index containing ~90,000 restaurant URLs. Each URL encodes the city name in the slug (e.g., `thirsty-bear-san-francisco`). The actor filters this list by your city input, then fetches each matching profile page.

**Data source:**
Every OpenTable restaurant profile page embeds (a) a JSON-LD `@type=Restaurant` block and (b) an inline application-state blob containing the most-recent reviews with full sub-ratings. Both are maintained by OpenTable, parsed from the same page in a single request — the most reliable and stable extraction method, with no fragile CSS class selectors.

***

### Pricing

Two pay-per-event prices:

- **Per restaurant record** delivered.
- **Per review record** delivered.

Reviews come from the same page as the restaurant (no extra request), so review pricing reflects the data value, not extra compute. No per-query or setup fees.

You do **not** need to supply your own proxy or API key. Access is fully handled by the actor.

***

### Usage examples

#### Lead generation for restaurant industry vendors

Scrape all Italian restaurants in NYC to build a targeted outreach list for a restaurant POS system or food delivery service:

```json
{
  "city": "new-york",
  "cuisine": "italian",
  "maxItems": 500
}
```

#### Restaurant data aggregation

Build a dining guide for a specific city by scraping all available restaurants:

```json
{
  "city": "chicago",
  "maxItems": 1000
}
```

#### Monitoring specific restaurants

Track data for a known set of competitor restaurants:

```json
{
  "restaurantUrls": [
    "https://www.opentable.com/r/nobu-new-york",
    "https://www.opentable.com/r/eleven-madison-park-new-york",
    "https://www.opentable.com/r/per-se-new-york"
  ]
}
```

***

### Supported cities

Any city where OpenTable has restaurant listings. The city input must match the format used in OpenTable slugs. Common formats:

- `san-francisco`
- `new-york`
- `los-angeles`
- `chicago`
- `miami`
- `seattle`
- `boston`
- `denver`
- `austin`
- `las-vegas`
- `washington-dc` (use `washington`)
- `portland`
- `atlanta`
- `philadelphia`

***

### Technical notes

- **Anti-bot:** handled via managed proxy (baked in, no buyer setup needed).
- **Data stability:** JSON-LD `@type=Restaurant` + inline application-state reviews — maintained by OpenTable, much more stable than scraped HTML. Reviews use the rich state blob (sub-ratings, dined date, helpfulness) with a JSON-LD review fallback.
- **Reviews:** ~10 most-recent reviews per restaurant, extracted from the same page (no extra request).
- **Rate:** ~1–2 restaurants/second (network-bound by managed proxy response times).
- **Coverage:** ~90,000 restaurant URLs across all US cities in sitemap.

***

### Output example

**Restaurant row** (`record_type: "restaurant"`, with nested `reviews[]`):

```json
{
  "record_type": "restaurant",
  "restaurant_id": "2",
  "name": "Thirsty Bear",
  "slug": "thirsty-bear-san-francisco",
  "url": "https://www.opentable.com/r/thirsty-bear-san-francisco",
  "description": "ThirstyBear is the first & only Certified Organic brewery in San Francisco...",
  "cuisine": ["Spanish", "Tapas / Small Plates", "Brewery"],
  "cuisine_str": "Spanish, Tapas / Small Plates, Brewery",
  "price_range": "$30 and under",
  "rating": 3.9,
  "review_count": 615,
  "accepts_reservations": false,
  "street_address": "661 Howard St.",
  "city": "San Francisco",
  "state": "CA",
  "zip_code": "94105",
  "country": "United States",
  "address": "661 Howard St., San Francisco, CA, 94105",
  "latitude": 37.78565,
  "longitude": -122.399734,
  "phone": "+1 415-974-0905",
  "opening_hours": ["Monday 11:30am–10:00pm", "Friday 11:30am–11:00pm"],
  "menu_url": null,
  "reviews_extracted": 10,
  "reviews": [ { "...": "see review row below" } ],
  "scraped_at": "2026-06-07T12:00:00Z"
}
```

**Review row** (`record_type: "review"`):

```json
{
  "record_type": "review",
  "restaurant_id": "2",
  "restaurant_name": "Thirsty Bear",
  "restaurant_slug": "thirsty-bear-san-francisco",
  "review_id": "OT-2-1804022929-150018263055",
  "reviewer_name": "JoeF",
  "reviewer_initials": "JF",
  "reviewer_metro": "San Francisco",
  "reviewer_review_count": 12,
  "overall_rating": 5,
  "food_rating": 5,
  "service_rating": 5,
  "ambience_rating": 4,
  "value_rating": 5,
  "noise_level": "MODERATE",
  "review_text": "Great craft beers. Tapas and paella were very good. Good service.",
  "dined_date": "2018-05-25",
  "review_date": "2018-05-27",
  "party_size": null,
  "occasion": "",
  "helpful_count": 0,
  "helpful_up": 0,
  "helpful_down": 0,
  "has_photos": false,
  "scraped_at": "2026-06-07T12:00:00Z"
}
```

***

### FAQ

**Do I need to provide my own proxy or API key?**
No. Access is fully handled by the actor. No external credentials needed.

**How much does it cost to scrape 1,000 restaurants?**
At the standard rate, 1,000 restaurant records cost $X. Compute costs are charged to your Apify account at standard Apify platform rates.

**Is this legal? Does it violate OpenTable's Terms of Service?**
This actor scrapes publicly accessible restaurant profile pages. The data extracted (name, address, phone, cuisine, hours) is factual business information. Users are responsible for complying with OpenTable's Terms of Service and applicable data protection laws in their jurisdiction. The actor should not be used to spam restaurants, harvest personal data, or automate reservations.

**Which cities are supported?**
Any city where OpenTable has restaurant listings. The city input must match OpenTable's URL slug format (e.g., `san-francisco`, `new-york`, `los-angeles`). See the Supported cities section above.

**What if my city returns 0 results?**
Check that the city slug matches exactly what OpenTable uses in URLs. For example, Washington D.C. uses `washington` not `washington-dc`. If unsure, look up any restaurant in that city on OpenTable and copy the city portion of the URL slug.

**Can I request custom data fields or bulk pricing?**
Yes — contact us via the actor Issues tab.

# Actor input Schema

## `restaurantUrls` (type: `array`):

OpenTable restaurant profile URLs to scrape directly. E.g. \['https://www.opentable.com/r/thirsty-bear-san-francisco']. Takes priority over city/cuisine search.

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

City name to search restaurants in. E.g. 'san-francisco', 'new-york', 'chicago'. Used when restaurantUrls is empty.

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

Optional cuisine keyword to filter restaurants. E.g. 'italian', 'sushi', 'french'. Leave empty for all cuisines.

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

Maximum number of restaurant records to return.

## `includeReviews` (type: `boolean`):

Also extract individual diner reviews for each restaurant (reviewer, overall + food/service/ambience/value sub-ratings, text, dined & review dates, helpful votes). Reviews come from the same page as the restaurant — no extra cost or slowdown beyond the per-review charge. Emitted as separate review rows AND nested under each restaurant.

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

Cap on individual reviews extracted per restaurant. OpenTable embeds ~10 of the most recent reviews on each restaurant page (we read those — one request per restaurant, no extra requests). Default 20 returns all embedded reviews.

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

Proxy settings. This actor uses a managed proxy layer (baked in) to bypass Akamai protection on OpenTable — no external proxy key is required from you.

## Actor input object example

```json
{
  "restaurantUrls": [],
  "city": "san-francisco",
  "maxItems": 10,
  "includeReviews": true,
  "maxReviewsPerRestaurant": 20
}
```

# Actor output Schema

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

Dataset containing Opentable Scraper records (record\_type, name, cuisine, price\_range, rating, review\_count, reviews\_extracted, city, address, phone, accepts\_reservations, url, restaurant\_name, reviewer\_name, overall\_rating, food\_rating, service\_rating, ambience\_rating).

# 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 = {
    "restaurantUrls": [],
    "city": "san-francisco",
    "cuisine": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/opentable-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 = {
    "restaurantUrls": [],
    "city": "san-francisco",
    "cuisine": "",
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/opentable-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 '{
  "restaurantUrls": [],
  "city": "san-francisco",
  "cuisine": ""
}' |
apify call bovi/opentable-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenTable Scraper — Reviews, Restaurants & Availability",
        "description": "Scrape OpenTable restaurants AND individual reviews (reviewer, overall + food/service/ambience sub-ratings, text, dined date, helpful votes), plus availability and listings. By city, cuisine, or URL. Two PPE events: per restaurant + per review.",
        "version": "0.1",
        "x-build-id": "90rTpMdSuFXDYExdK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~opentable-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-opentable-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/bovi~opentable-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bovi-opentable-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/bovi~opentable-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-opentable-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": {
                    "restaurantUrls": {
                        "title": "Restaurant URLs",
                        "type": "array",
                        "description": "OpenTable restaurant profile URLs to scrape directly. E.g. ['https://www.opentable.com/r/thirsty-bear-san-francisco']. Takes priority over city/cuisine search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "city": {
                        "title": "City (for search mode)",
                        "type": "string",
                        "description": "City name to search restaurants in. E.g. 'san-francisco', 'new-york', 'chicago'. Used when restaurantUrls is empty."
                    },
                    "cuisine": {
                        "title": "Cuisine filter (optional)",
                        "type": "string",
                        "description": "Optional cuisine keyword to filter restaurants. E.g. 'italian', 'sushi', 'french'. Leave empty for all cuisines."
                    },
                    "maxItems": {
                        "title": "Max restaurants",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of restaurant records to return.",
                        "default": 10
                    },
                    "includeReviews": {
                        "title": "Include individual reviews",
                        "type": "boolean",
                        "description": "Also extract individual diner reviews for each restaurant (reviewer, overall + food/service/ambience/value sub-ratings, text, dined & review dates, helpful votes). Reviews come from the same page as the restaurant — no extra cost or slowdown beyond the per-review charge. Emitted as separate review rows AND nested under each restaurant.",
                        "default": true
                    },
                    "maxReviewsPerRestaurant": {
                        "title": "Max reviews per restaurant",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Cap on individual reviews extracted per restaurant. OpenTable embeds ~10 of the most recent reviews on each restaurant page (we read those — one request per restaurant, no extra requests). Default 20 returns all embedded reviews.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. This actor uses a managed proxy layer (baked in) to bypass Akamai protection on OpenTable — no external proxy key is required from you."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```