# Resy Restaurant Scraper (`memo23/resy-restaurant-scraper`) Actor

Scrape Resy restaurant data from any of 2,129 cities: name, cuisine, price band, rating with count, address, coordinates, phone, website, photos — plus live reservation slots for your chosen day and party size. Search by city and cuisine or paste venue URLs. JSON or CSV out.

- **URL**: https://apify.com/memo23/resy-restaurant-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 restaurant venues

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Resy Restaurant Scraper — Venues | Ratings | Contact Info | Live Reservation Availability

Scrape restaurant data from **Resy** at scale: search any of Resy's 2,129 cities (optionally filtered by cuisine or keyword), or fetch specific venues by URL. Every row carries the full venue record — name, cuisine, price band, Resy rating with rating count, neighborhood, full address, coordinates, phone, website, menu link, social handles, photos — and, when you want it, the **live reservation slots** for a chosen day and party size.

Built on Resy's own JSON API rather than HTML scraping: faster, cheaper, and stable against site redesigns. No login, no browser, no cookies.

![How Resy Restaurant Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-resy.png)

### Why use this scraper

- **City-wide coverage in one input.** Type `New York` and the scraper resolves it against Resy's official location table (2,129 cities worldwide), then walks the paginated venue search until the city is exhausted.
- **Live availability, not just static data.** Opt in to `includeAvailability` and each venue row gains the actual bookable slots (start/end time, table type, party-size range) for your chosen day.
- **Real contact data.** Resy exposes the restaurant's own phone number and website for most venues — both land directly on the row.
- **Exact-city results by default.** Resy's search is distance-ranked without a radius cut-off, so naive scrapers drift into neighboring cities. This one filters to the searched city and stops paging when results leave it.
- **One row per venue.** No padding, no duplicate rows — you pay for venues, not noise.

### Overview

| | |
|---|---|
| Data source | Resy public JSON API (search, venue detail, availability) |
| Discovery | City search (2,129 cities), cuisine/keyword filter, direct venue URLs |
| Output | One dataset row per venue; availability rides along on the row |
| Auth | None required — the actor manages Resy's public widget key automatically |
| Formats | JSON, CSV, Excel, XML via the Apify dataset |

### Supported inputs

1. **Cities** — plain city names: `New York`, `Los Angeles`, `London`, `Paris`, `Austin`, `Toronto`… Each becomes one paginated search.
2. **Search term / cuisine** — optional free text applied to every city search: `italian`, `steakhouse`, `sushi`, `omakase`, a venue name, any keyword.
3. **Direct venue URLs** — `https://resy.com/cities/{city}/venues/{slug}`, mixed freely with city searches in the same run.
4. **Result filters** — `minRating` (Resy 5-point scale), `priceRanges` (`$` to `$$$$`), and `onlyWithAvailability` (drop venues with no bookable slots for your day/party size). Rating and price filters run on the search hit itself, before the detail fetch, so filtered venues cost nothing.

### Use cases

- **Market research** — inventory every Resy venue in a city with price band, cuisine, and rating; compare neighborhoods or cuisines.
- **Availability monitoring** — track which venues have open tables for a given day and party size; spot hard-to-book restaurants.
- **Lead generation** — restaurant phone numbers, websites, and Instagram handles for hospitality-focused outreach (plus opt-in email discovery).
- **Competitive analysis** — ratings and rating counts across a whole market, joined to OpenTable/TripAdvisor data via name and coordinates.
- **Apps and directories** — structured venue records with photos, coordinates, and booking links.

### How it works

1. Your city input is resolved against Resy's official location table to exact coordinates.
2. The venue search is walked page by page (50 venues per page), streamed — venue details fan out in parallel while the next page is still loading.
3. Each unique venue is fetched once from the venue-detail endpoint (full record).
4. With availability enabled, one extra call per venue pulls the live slots for your day and party size.
5. Rows land in the dataset as they finish — no end-of-run batch, so partial results survive any interruption.

### Input configuration

Example — every Italian restaurant in New York, with live slots for a party of 2:

```json
{
    "cities": ["New York"],
    "query": "italian",
    "includeAvailability": true,
    "day": "2026-08-07",
    "partySize": 2,
    "maxItems": 200
}
````

Example — only well-rated, bookable steakhouses in the upper price bands:

```json
{
    "cities": ["New York"],
    "query": "steakhouse",
    "minRating": 4,
    "priceRanges": ["$$$", "$$$$"],
    "includeAvailability": true,
    "onlyWithAvailability": true,
    "maxItems": 50
}
```

Example — specific venues only:

```json
{
    "startUrls": [
        "https://resy.com/cities/new-york-ny/venues/carbone",
        "https://resy.com/cities/new-york-ny/venues/4-charles-prime-rib"
    ],
    "includeAvailability": true
}
```

### Output overview

One row per venue. Sample (trimmed):

```json
{
    "source": "Resy",
    "venueId": 87058,
    "name": "Foodance Italian Restaurant",
    "resyUrl": "https://resy.com/cities/new-york-ny/venues/foodance-italian-restaurant",
    "cuisine": "Italian",
    "priceRange": "$$",
    "rating": { "score": 4.64, "count": 228, "scale": 5, "source": "Resy" },
    "description": "Foodance Italian Restaurant is an Italian restaurant in the Hell's Kitchen neighborhood of New York.",
    "neighborhood": "Hell's Kitchen",
    "address1": "468 W 47th St",
    "locality": "New York",
    "region": "NY",
    "postalCode": "10036",
    "country": "United States",
    "latitude": 40.7627,
    "longitude": -73.9928,
    "phone": "+16464227755",
    "website": "https://www.foodancerestaurant.com",
    "social": [{ "name": "instagram", "value": "foodance__restaurant" }],
    "images": ["https://image.resy.com/3/003/2/87058/....jpg"],
    "availability": {
        "day": "2026-08-07",
        "partySize": 2,
        "slots": [
            { "start": "2026-08-07 12:00:00", "end": "2026-08-07 13:30:00", "type": "Dining Room", "size": { "min": 1, "max": 2 } }
        ]
    },
    "scrapedAt": "2026-07-24T07:41:02.113Z"
}
```

### Key output fields

| Field | Meaning |
|---|---|
| `venueId` | Resy's numeric venue ID; `externalIds` adds Google Place ID and Foursquare ID where present |
| `rating` | Resy diner rating: score (5-point scale), total rating count |
| `priceRange` | `$` to `$$$$` (Resy's own price band) |
| `phone` / `website` / `menuUrl` | The restaurant's own contact details as listed on Resy |
| `availability.slots` | Live bookable slots for the requested day/party size — start, end, table type, party-size range |
| `collections` | Resy editorial collections the venue appears in |
| `venueGroup` | Parent restaurant group, when the venue belongs to one |
| `contactEmail` / `emailEnrichment` | Only with the opt-in email enrichment enabled |

### FAQ

**Does it scrape written reviews?**
No — Resy doesn't publish written diner reviews. You get the aggregate rating and rating count. For full-text restaurant reviews, pair this with our [OpenTable scraper](https://apify.com/memo23/opentable-reviews-cheerio).

**Why does a famous venue show zero availability slots?**
Because it genuinely has none bookable for that day — high-demand venues (e.g. Carbone) release tables at fixed times and sell out in minutes. Try other days or party sizes.

**Can I get venues outside the searched city?**
Yes — set `onlyExactCity: false` and the distance-ranked search will keep going into neighboring cities.

**Do I need a Resy account or API key?**
No. The actor uses Resy's public widget key and refreshes it automatically at startup.

**How many venues does a city have?**
New York has roughly 2,500 venues matching a typical cuisine search and 20k+ overall reachable records; most cities are far smaller. Use `maxItems` to cap billing.

### Support

- **Issues tab** — fastest way to reach us; we usually respond within 24 hours.
- Custom features, bulk runs, or a managed data feed: open an issue describing what you need.

### Additional services

- **Email enrichment (opt-in)** — discover a contact email for each restaurant from its own website. Adds `contactEmail`, `contactWebsite`, and a detailed `emailEnrichment` object.
- **Scheduling** — run daily/weekly with Apify Schedules; combine with `includeAvailability` for availability monitoring.

### Explore more scrapers

- [OpenTable Scraper — details, menus, full reviews, availability](https://apify.com/memo23/opentable-reviews-cheerio)
- [TheFork Restaurant Scraper](https://apify.com/memo23/thefork-restaurant-scraper)
- [TripAdvisor Scraper](https://apify.com/memo23/tripadvisor-scraper)
- [All memo23 actors](https://apify.com/memo23)

### ⚠️ Disclaimer

This actor collects only publicly available data from Resy's public interfaces. It does not bypass authentication, collect personal data of private individuals, or circumvent access controls. You are responsible for how you use the data, including compliance with Resy's terms of service, applicable data-protection laws (GDPR, CCPA), and local regulations in your jurisdiction. This actor is not affiliated with, endorsed by, or sponsored by Resy Network Inc.

### SEO Keywords

resy scraper, resy restaurant scraper, resy api, resy data extraction, scrape resy, resy reservation availability, resy venue data, restaurant data scraper, restaurant availability api, resy restaurant list, resy ratings scraper, restaurant lead generation, resy new york restaurants, restaurant market research, reservation slots scraper

# Actor input Schema

## `cities` (type: `array`):

City names, matched against Resy's official location table of 2,129 cities (e.g. `New York`, `Los Angeles`, `London`, `Paris`). Each city becomes one paginated venue search.

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

Free-text filter applied to every city search — a cuisine (`italian`, `steakhouse`, `sushi`), a venue name, or any keyword. Leave empty to get every venue in the city.

## `onlyExactCity` (type: `boolean`):

Resy's search is distance-ranked without a radius cut-off, so deep pagination drifts into other cities. Keep this on to return only venues that actually belong to the searched city; turn it off to also collect nearby-city results.

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

Resy venue URLs of the form `https://resy.com/cities/{city}/venues/{slug}`. Each URL is fetched as one venue detail, in addition to any city searches.

## `includeAvailability` (type: `boolean`):

When enabled, each venue row gets an `availability` object with the bookable slots (start/end time, table type) for the chosen day and party size.

## `day` (type: `string`):

ISO date for the availability lookup. Defaults to two weeks from today — Resy's own booking horizon. Only used when live reservation slots are enabled.

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

Party size for the availability lookup. Only used when live reservation slots are enabled.

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

Drop venues rated below this on Resy's 5-point scale (e.g. 4). Leave empty to keep all.

## `priceRanges` (type: `array`):

Keep only venues in these price bands. Empty = all bands.

## `onlyWithAvailability` (type: `boolean`):

Drop venues that have zero bookable slots for the chosen day and party size. Requires live reservation slots to be enabled.

## `enrichEmails` (type: `boolean`):

If enabled, tries to find a contact email for each restaurant by scraping the venue's own website (Resy usually exposes it) or discovering it via Clearbit. Adds contactEmail + contactWebsite columns plus a detailed emailEnrichment object. Best-effort.

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

Hard cap on the number of venue rows collected. A full city can hold thousands of venues; use this cap to limit billing.

## `maxConcurrency` (type: `integer`):

Maximum number of venue detail calls processed in parallel.

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

Resy's API is served through standard CDN protection; residential proxies are the safe default for larger runs.

## Actor input object example

```json
{
  "cities": [
    "New York"
  ],
  "onlyExactCity": true,
  "includeAvailability": false,
  "partySize": 2,
  "onlyWithAvailability": false,
  "enrichEmails": false,
  "maxItems": 100,
  "maxConcurrency": 10
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/resy-restaurant-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 = {
    "cities": ["New York"],
    "query": "",
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Resy Restaurant Scraper",
        "description": "Scrape Resy restaurant data from any of 2,129 cities: name, cuisine, price band, rating with count, address, coordinates, phone, website, photos — plus live reservation slots for your chosen day and party size. Search by city and cuisine or paste venue URLs. JSON or CSV out.",
        "version": "0.0",
        "x-build-id": "gODtue3utd6MJQKZw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~resy-restaurant-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-resy-restaurant-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/memo23~resy-restaurant-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-resy-restaurant-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/memo23~resy-restaurant-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-resy-restaurant-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": {
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "City names, matched against Resy's official location table of 2,129 cities (e.g. `New York`, `Los Angeles`, `London`, `Paris`). Each city becomes one paginated venue search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "Search term / cuisine (optional)",
                        "type": "string",
                        "description": "Free-text filter applied to every city search — a cuisine (`italian`, `steakhouse`, `sushi`), a venue name, or any keyword. Leave empty to get every venue in the city."
                    },
                    "onlyExactCity": {
                        "title": "Only venues in the searched city",
                        "type": "boolean",
                        "description": "Resy's search is distance-ranked without a radius cut-off, so deep pagination drifts into other cities. Keep this on to return only venues that actually belong to the searched city; turn it off to also collect nearby-city results.",
                        "default": true
                    },
                    "startUrls": {
                        "title": "Direct venue URLs",
                        "type": "array",
                        "description": "Resy venue URLs of the form `https://resy.com/cities/{city}/venues/{slug}`. Each URL is fetched as one venue detail, in addition to any city searches.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeAvailability": {
                        "title": "Include live reservation slots",
                        "type": "boolean",
                        "description": "When enabled, each venue row gets an `availability` object with the bookable slots (start/end time, table type) for the chosen day and party size.",
                        "default": false
                    },
                    "day": {
                        "title": "Availability day (YYYY-MM-DD)",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "ISO date for the availability lookup. Defaults to two weeks from today — Resy's own booking horizon. Only used when live reservation slots are enabled."
                    },
                    "partySize": {
                        "title": "Party size",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Party size for the availability lookup. Only used when live reservation slots are enabled.",
                        "default": 2
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop venues rated below this on Resy's 5-point scale (e.g. 4). Leave empty to keep all."
                    },
                    "priceRanges": {
                        "title": "Price bands",
                        "type": "array",
                        "description": "Keep only venues in these price bands. Empty = all bands.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "$",
                                "$$",
                                "$$$",
                                "$$$$"
                            ],
                            "enumTitles": [
                                "$ — under $30",
                                "$$ — $30-50",
                                "$$$ — $50-75",
                                "$$$$ — over $75"
                            ]
                        }
                    },
                    "onlyWithAvailability": {
                        "title": "Only venues with bookable slots",
                        "type": "boolean",
                        "description": "Drop venues that have zero bookable slots for the chosen day and party size. Requires live reservation slots to be enabled.",
                        "default": false
                    },
                    "enrichEmails": {
                        "title": "Enrich with restaurant contact emails (experimental)",
                        "type": "boolean",
                        "description": "If enabled, tries to find a contact email for each restaurant by scraping the venue's own website (Resy usually exposes it) or discovering it via Clearbit. Adds contactEmail + contactWebsite columns plus a detailed emailEnrichment object. Best-effort.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum venues to scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the number of venue rows collected. A full city can hold thousands of venues; use this cap to limit billing.",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of venue detail calls processed in parallel.",
                        "default": 10
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Resy's API is served through standard CDN protection; residential proxies are the safe default for larger runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
