# Zomato Restaurant Scraper - City, Cuisine, Contact (`anshumanatrey/zomato-restaurant-scraper`) Actor

Scrape restaurants from any Zomato city page. Each restaurant pushed as one record with name, phone, address, cuisines, rating, cost for two. Built for B2B sales, food-tech research, ghost kitchen analysis, and restaurant competitor intelligence.

- **URL**: https://apify.com/anshumanatrey/zomato-restaurant-scraper.md
- **Developed by:** [Anshuman Atrey](https://apify.com/anshumanatrey) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 restaurant records

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

## Zomato Restaurant Scraper

📦 **Open source · MIT:** [github.com/AnshumanAtrey/zomato-restaurant-scraper](https://github.com/AnshumanAtrey/zomato-restaurant-scraper)


Scrape restaurant listings from [Zomato](https://www.zomato.com) by city and cuisine. Get structured records with **name, phone, address, cuisines, rating, and cost for two** — no Zomato account required.

Built for B2B sales teams, food-tech researchers, ghost-kitchen operators, lead-gen agencies, and competitor intelligence.

### Quick start

1. **Pick a City** from the dropdown (Bangalore, Delhi NCR, Mumbai, Dubai, Singapore, etc. — 40 cities)
2. **Pick a Listing Type** (Best, All, Dinner, Breakfast)
3. **Optionally pick a Cuisine** filter (Biryani, Pizza, North Indian, Chinese, etc. — 24 options)
4. **Set how many restaurants** you want (default 50, up to 1000)
5. Click **Run**

Typical 50-restaurant scan completes in 3-7 minutes.

### What you get

Each restaurant is pushed as one dataset record:

| Field | Example |
|---|---|
| `name` | Truffles |
| `url` | https://www.zomato.com/bangalore/truffles-st-marks-road-central-bangalore/info |
| `slug` | truffles-st-marks-road-central-bangalore |
| `phone` | +91 80 4111 2400 |
| `address` | 22, St Marks Road, Bangalore |
| `cuisines` | American, Burger, Continental |
| `rating` | 4.5 |
| `costForTwo` | ₹800 |
| `city` | bangalore |
| `area` | Central Bangalore |
| `timestamp` | 2026-05-22T09:43:18Z |

A final `summary` record reports `restaurantsScraped`, `restaurantsFound`, `failures`, `duration`, and `sourceUrls`.

### Common use cases

#### Build a B2B restaurant lead list
Pick `Mumbai`, `Best restaurants`, `maxRestaurants: 200`. Export the CSV. You now have 200 verified phone numbers + addresses for outreach.

#### Scrape a specific cuisine in a specific city
Pick `Hyderabad`, `All restaurants`, `Cuisine: Biryani`, `maxRestaurants: 100`.

#### Scrape a city not in the dropdown
Use the **Custom city** field under "Advanced overrides". Type `Tirunelveli`, `Erode`, `Coorg`, `Manali`, `Madurai`, `Varanasi` — auto-converted to the right Zomato URL.

#### Scrape a category not in the dropdown
Use the **Custom cuisine** field. `Momos`, `Kebab`, `Hyderabadi`, `Awadhi` all work.

#### Scrape an exact Zomato URL you already have
Paste it into **Custom URL** under "Advanced overrides". Overrides every other dropdown.

### Inputs

#### Main fields

- **City** — Pick from 40 Zomato cities across India, UAE, Qatar, Oman, Malaysia, Singapore, Philippines, Sri Lanka, Portugal
- **Listing Type** — `Best restaurants` (curated top picks), `All restaurants`, `Dinner spots`, or `Breakfast spots`
- **Cuisine** — Optional filter across 24 cuisine categories, or "Any" for no filter
- **How many restaurants** — Cap on results (1-1000). Start with 20-50 to verify, then scale up
- **Scan depth**:
  - `Quick` — restaurant URLs + names only (fast, cheap, useful for bulk URL lists)
  - `Standard` — full data: phone, address, rating, cost (default — recommended for B2B leads)
  - `Deep` — full data with extra retries for blocked pages (slowest, highest yield)

#### Advanced overrides (optional)

- **Custom city** — Type any Zomato city not in the dropdown. Auto-slugified
- **Custom cuisine** — Type any Zomato cuisine category not in the dropdown
- **Custom URL** — Paste any Zomato listing URL to scrape it directly. Overrides everything above

#### Runtime

- **Run timeout (seconds)** — Hard kill after this many seconds (default 1800 = 30 min)

### How it works

1. **Listing page**: navigates to the constructed Zomato URL, scrolls to load lazy content, extracts all restaurant detail URLs (handles both `/info` and `/order` URL patterns)
2. **Detail pages**: visits each restaurant page concurrently using fast HTTP fetches (Cheerio) — typically 5-10x faster than full browser rendering
3. **Auto-fallback**: if the primary URL returns 0 restaurants, automatically retries `/{city}/restaurants` as a fallback

Uses **Apify Residential Proxy** to avoid rate-limit issues.

### Pricing

**$0.005 per restaurant record.** A typical 50-restaurant scan costs ~$0.26.

| Scan size | Approx cost |
|---|---|
| 20 restaurants | $0.10 |
| 50 restaurants | $0.25 |
| 100 restaurants | $0.50 |
| 500 restaurants | $2.50 |
| 1000 restaurants | $5.00 |

### FAQ

#### Does it scrape menu items / dishes?
No — it scrapes restaurant *listings* (name, phone, address, etc.), not menus. For menu data, use a different actor that hits individual restaurant pages with menu rendering.

#### Can I scrape "Dahi Puri" or "Tandoor"?
Zomato organizes by **cuisine category**, not by individual dish. Specific dishes like `dahi-puri` don't have their own URL on Zomato. Use a broader category like **Street Food** or **North Indian** instead.

#### Can I scrape an entire state like "Tamil Nadu"?
Zomato has no state-level URLs. Pick a specific city instead — e.g., for Tamil Nadu use `Chennai`, `Coimbatore`, or custom-city `Madurai`/`Tirunelveli`.

#### Does it work for cities outside the dropdown?
Yes. Use the **Custom city** field with the city name — `Erode`, `Coorg`, `Manali`, `Varanasi`, etc. The actor auto-slugifies and auto-falls-back to `/{city}/restaurants` if `/best-restaurants` doesn't exist for that smaller city.

#### Why didn't I get any results?
Most likely causes:
- Off-list cuisine combined with quick scan — try `Standard` depth
- City has no listings for that cuisine — try removing the cuisine filter
- Custom URL is malformed — paste it in a browser first to verify

#### What about international cities?
Dubai, Abu Dhabi, Sharjah (UAE), Doha (Qatar), Muscat (Oman), Kuala Lumpur (Malaysia), Singapore, Manila, Colombo, Lisbon are in the dropdown. Other Zomato international cities (e.g., Sydney, Auckland) work via the **Custom city** field.

#### Is the data accurate / fresh?
Pulled live from Zomato at run time. Phone numbers and addresses are exactly what Zomato displays today. Ratings may lag slightly behind Zomato's internal scoring.

#### Is this legal?
Scrapes only publicly visible data on Zomato. You are responsible for complying with Zomato's [Terms of Service](https://www.zomato.com/policies/terms-of-service/), GDPR/DPDP, and local laws. **Don't use phone numbers for mass cold-calling without consent.**

### Output structure

```json
{
  "recordType": "restaurant",
  "name": "Truffles",
  "url": "https://www.zomato.com/bangalore/truffles-st-marks-road-central-bangalore/info",
  "slug": "truffles-st-marks-road-central-bangalore",
  "phone": "+91 80 4111 2400",
  "address": "22, St Marks Road, Bangalore",
  "cuisines": ["American", "Burger", "Continental"],
  "rating": 4.5,
  "costForTwo": "₹800",
  "city": "bangalore",
  "area": "Central Bangalore",
  "timestamp": "2026-05-22T09:43:18Z"
}
````

Plus one `summary` record per run:

```json
{
  "recordType": "summary",
  "restaurantsScraped": 50,
  "restaurantsFound": 52,
  "failures": 2,
  "duration": 287,
  "sourceUrls": ["https://www.zomato.com/bangalore/best-restaurants"]
}
```

### Pairs nicely with

Enrich your restaurant lead lists with deeper intel:

- **[Holehe Email OSINT](https://apify.com/anshumanatrey/holehe-email-osint)** — After scraping restaurant emails from their websites, check which platforms each restaurant owner is on
- **[NetIntel](https://apify.com/anshumanatrey/netintel)** — WHOIS, DNS, SSL, GeoIP of each restaurant's website
- **[Social Analyzer](https://apify.com/anshumanatrey/social-analyzer)** — Find a restaurant brand's social media presence across 900+ platforms
- **[theHarvester](https://apify.com/anshumanatrey/theharvester-osint)** — Discover all subdomains + emails for a restaurant chain's primary domain
- **[nmap](https://apify.com/anshumanatrey/nmap-scanner)** — Network recon (for IT/security workflows, not lead-gen)
- **[Bug Bounty Finder](https://apify.com/anshumanatrey/bug-bounty-finder)** — Audit a restaurant chain's disclosure-program coverage

### Credits

Built by [Anshuman Atrey](https://apify.com/anshumanatrey) using Apify SDK, Crawlee, Puppeteer, and Cheerio.

### Disclaimer

This scraper accesses publicly available data on Zomato. You are responsible for complying with Zomato's [Terms of Service](https://www.zomato.com/policies/terms-of-service/) and applicable laws in your jurisdiction. Use the data responsibly — avoid mass cold-calling without consent.

# Actor input Schema

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

Pick the Zomato city to scrape.

## `listingType` (type: `string`):

Which list of restaurants do you want?

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

Filter by cuisine. Leave on "Any" for no filter.

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

Cap on results per scan. Start small (20-50) and increase as needed.

## `scanDepth` (type: `string`):

Quick = restaurant URLs + names only (fast, cheap). Standard = full data (phone, address, rating, cost). Deep = full data with extra retries for blocked pages.

## `customCity` (type: `string`):

City name not in the dropdown? Type it here. Examples: 'Erode', 'Tirunelveli', 'Coorg', 'Manali', 'Madurai', 'Varanasi'. Auto-converted to slug (lowercase + dashes). Tip: Zomato uses CITY URLs only — there's no state-level URL, so 'Tamil Nadu' won't work; pick a city like 'Madurai' or 'Coimbatore'.

## `customCuisine` (type: `string`):

Cuisine not in the dropdown? Type it here. Examples that work: 'Momos', 'Kebab', 'Hyderabadi', 'Awadhi'. Auto-converted to slug. Note: Zomato only has CUISINE CATEGORIES — specific dishes like 'Dahi Puri' or 'Tandoor' won't have their own URL (those aren't cuisine categories). For dish-level searches, use a broader category like 'Street Food' or 'North Indian'.

## `customUrl` (type: `string`):

Paste any Zomato listing URL. Overrides every dropdown + custom field above. Example: https://www.zomato.com/dehradun/restaurants/biryani.

## `timeoutSeconds` (type: `integer`):

Hard kill the scan after this many seconds. Default 1800 (30 min) handles most multi-city scans.

## Actor input object example

```json
{
  "city": "bangalore",
  "listingType": "best-restaurants",
  "cuisine": "",
  "maxRestaurants": 50,
  "scanDepth": "standard",
  "timeoutSeconds": 1800
}
```

# Actor output Schema

## `restaurants` (type: `string`):

Restaurant records (recordType=restaurant) plus a final summary record (recordType=summary). Filter by recordType=restaurant for clean table view.

# 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 = {
    "city": "bangalore"
};

// Run the Actor and wait for it to finish
const run = await client.actor("anshumanatrey/zomato-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 = { "city": "bangalore" }

# Run the Actor and wait for it to finish
run = client.actor("anshumanatrey/zomato-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 '{
  "city": "bangalore"
}' |
apify call anshumanatrey/zomato-restaurant-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zomato Restaurant Scraper - City, Cuisine, Contact",
        "description": "Scrape restaurants from any Zomato city page. Each restaurant pushed as one record with name, phone, address, cuisines, rating, cost for two. Built for B2B sales, food-tech research, ghost kitchen analysis, and restaurant competitor intelligence.",
        "version": "1.0",
        "x-build-id": "t2DLcxOhntKvuKbsE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/anshumanatrey~zomato-restaurant-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-anshumanatrey-zomato-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/anshumanatrey~zomato-restaurant-scraper/runs": {
            "post": {
                "operationId": "runs-sync-anshumanatrey-zomato-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/anshumanatrey~zomato-restaurant-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-anshumanatrey-zomato-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",
                "required": [
                    "city"
                ],
                "properties": {
                    "city": {
                        "title": "City",
                        "enum": [
                            "bangalore",
                            "delhi-ncr",
                            "mumbai",
                            "chennai",
                            "hyderabad",
                            "kolkata",
                            "pune",
                            "ahmedabad",
                            "jaipur",
                            "lucknow",
                            "chandigarh",
                            "noida",
                            "gurgaon",
                            "kochi",
                            "goa",
                            "dehradun",
                            "indore",
                            "bhopal",
                            "coimbatore",
                            "mysore",
                            "vadodara",
                            "visakhapatnam",
                            "patna",
                            "agra",
                            "amritsar",
                            "surat",
                            "nagpur",
                            "kanpur",
                            "jodhpur",
                            "thiruvananthapuram",
                            "dubai",
                            "abu-dhabi",
                            "sharjah",
                            "doha",
                            "muscat",
                            "kuala-lumpur",
                            "singapore",
                            "manila",
                            "colombo",
                            "lisbon"
                        ],
                        "type": "string",
                        "description": "Pick the Zomato city to scrape.",
                        "default": "bangalore"
                    },
                    "listingType": {
                        "title": "Listing Type",
                        "enum": [
                            "best-restaurants",
                            "restaurants",
                            "dinner",
                            "breakfast"
                        ],
                        "type": "string",
                        "description": "Which list of restaurants do you want?",
                        "default": "best-restaurants"
                    },
                    "cuisine": {
                        "title": "Cuisine (optional)",
                        "enum": [
                            "",
                            "north-indian",
                            "south-indian",
                            "chinese",
                            "italian",
                            "japanese",
                            "thai",
                            "mexican",
                            "biryani",
                            "pizza",
                            "burger",
                            "cafes",
                            "bakery",
                            "continental",
                            "mughlai",
                            "desserts",
                            "street-food",
                            "fast-food",
                            "seafood",
                            "healthy-food",
                            "beverages",
                            "mediterranean",
                            "lebanese",
                            "korean",
                            "vietnamese"
                        ],
                        "type": "string",
                        "description": "Filter by cuisine. Leave on \"Any\" for no filter.",
                        "default": ""
                    },
                    "maxRestaurants": {
                        "title": "How many restaurants?",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on results per scan. Start small (20-50) and increase as needed.",
                        "default": 50
                    },
                    "scanDepth": {
                        "title": "Scan depth",
                        "enum": [
                            "quick",
                            "standard",
                            "deep"
                        ],
                        "type": "string",
                        "description": "Quick = restaurant URLs + names only (fast, cheap). Standard = full data (phone, address, rating, cost). Deep = full data with extra retries for blocked pages.",
                        "default": "standard"
                    },
                    "customCity": {
                        "title": "Custom city (overrides City dropdown)",
                        "type": "string",
                        "description": "City name not in the dropdown? Type it here. Examples: 'Erode', 'Tirunelveli', 'Coorg', 'Manali', 'Madurai', 'Varanasi'. Auto-converted to slug (lowercase + dashes). Tip: Zomato uses CITY URLs only — there's no state-level URL, so 'Tamil Nadu' won't work; pick a city like 'Madurai' or 'Coimbatore'."
                    },
                    "customCuisine": {
                        "title": "Custom cuisine (overrides Cuisine dropdown)",
                        "type": "string",
                        "description": "Cuisine not in the dropdown? Type it here. Examples that work: 'Momos', 'Kebab', 'Hyderabadi', 'Awadhi'. Auto-converted to slug. Note: Zomato only has CUISINE CATEGORIES — specific dishes like 'Dahi Puri' or 'Tandoor' won't have their own URL (those aren't cuisine categories). For dish-level searches, use a broader category like 'Street Food' or 'North Indian'."
                    },
                    "customUrl": {
                        "title": "Custom URL (full override)",
                        "type": "string",
                        "description": "Paste any Zomato listing URL. Overrides every dropdown + custom field above. Example: https://www.zomato.com/dehradun/restaurants/biryani."
                    },
                    "timeoutSeconds": {
                        "title": "Run timeout (seconds)",
                        "minimum": 60,
                        "maximum": 7200,
                        "type": "integer",
                        "description": "Hard kill the scan after this many seconds. Default 1800 (30 min) handles most multi-city scans.",
                        "default": 1800
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
