# UberEats Menu Scraper (`xtracto/ubereats-menu-scraper`) Actor

Scrape UberEats: list restaurants near a location (lat/lng) and pull a store's full menu — items, prices, descriptions, and modifier groups. Feed and store modes; one row per menu item for price monitoring.

- **URL**: https://apify.com/xtracto/ubereats-menu-scraper.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (community)
- **Categories:** Other, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

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

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

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

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

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

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

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

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


# README

## UberEats Menu Scraper

Find restaurants near any location and pull their **full menus** — items, prices, descriptions, ratings, delivery estimates, and optional add-on choices. Perfect for price monitoring, menu intelligence, competitor tracking, and ghost-kitchen discovery.

### Why use this actor

- **No account, no login, no API key** — give it a location or a restaurant link and run.
- **Two ways to work**: list every restaurant near a point on the map, or pull the complete menu of specific restaurants you already have.
- **Real prices and menu detail** — item names, descriptions, prices, sold-out status, photos, and (optionally) the full add-on / customization choices for each item.
- **Store intelligence** — rating, price level, cuisine tags, phone number, address, coordinates, delivery time estimates, and current offers.
- **One row per menu item** (best for price tracking) or one row per store with the menu nested — your choice.
- **Clean, structured output**, automatic retries, runs on a schedule, exports to JSON / CSV / Excel. No scrapers or browsers to babysit.

### How it works

1. Pick a **mode**: *feed* (restaurants near a location) or *store* (menus for specific restaurants).
2. For feed mode, give one or more locations (latitude/longitude). For store mode, paste restaurant links or ids.
3. The actor lists the nearby restaurants and/or reads each restaurant's full menu.
4. Each restaurant or menu item becomes one row in your dataset. Turn on add-ons to also capture every customization choice.

You never manage scrapers, browsers, or blocks — just provide locations or restaurants and read the results.

### Input

**Mode: Feed — restaurants near a location**

```json
{
  "mode": "feed",
  "locations": [
    { "latitude": 40.7128, "longitude": -74.006, "title": "New York" }
  ],
  "includeMenus": false,
  "localeCode": "us",
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
````

**Mode: Store — full menu of specific restaurants**

```json
{
  "mode": "store",
  "stores": [
    "https://www.ubereats.com/store/ess-a-bagel-115-broadway/DxhTGkXoURuZAGDJWnguWA"
  ],
  "itemsAsRows": true,
  "includeModifiers": false,
  "location": { "latitude": 40.7128, "longitude": -74.006, "title": "New York" },
  "localeCode": "us",
  "maxItems": 0
}
```

| Field | Mode | Type | Description |
|-------|------|------|-------------|
| `mode` | — | string | `feed` (restaurants near a location) or `store` (menu of specific restaurants). Default `feed`. |
| `locations` | feed | array | One or more `{latitude, longitude, title}` objects (or `"lat,lng"` strings). Defaults to New York. |
| `includeMenus` | feed | boolean | Also pull each nearby restaurant's full menu. Slower. Default `false`. |
| `stores` | store | array of strings | Restaurant links (`https://www.ubereats.com/store/...`) or raw store ids. |
| `itemsAsRows` | store | boolean | `true` (default) = one row per menu item; `false` = one row per restaurant with the menu nested inside. |
| `includeModifiers` | both | boolean | Also capture each item's add-on / customization choices. Slower. Default `false`. |
| `location` | store | object | Optional location near the store, used to pick the right market. Defaults to New York. |
| `localeCode` | — | string | Country / locale for results (`us`, `gb`, `ca`, `en-US`, …). |
| `maxItems` | — | integer | Cap on total rows. `0` = no cap. |
| `maxConcurrency` | — | integer | How many locations / restaurants to process in parallel. Default 3. |
| `proxyConfiguration` | — | object | US residential proxy is recommended and set by default. |

### Output

**Feed mode** — one row per nearby restaurant:

```json
{
  "_input": "40.7128,-74.006",
  "_scrapedAt": "2026-07-09T11:09:31Z",
  "_source": "S1-feed",
  "recordType": "STORE",
  "storeUuid": "0f18531a-45e8-511b-9900-60c95a782e58",
  "title": "Ess-a-Bagel",
  "url": "https://www.ubereats.com/store/ess-a-bagel-115-broadway/DxhTGkXoURuZAGDJWnguWA",
  "cityName": "new_york",
  "ratingText": "4.7",
  "ratingAccessibility": "A top rated restaurant with 4.7 out of 5 stars based on more than 260 reviews.",
  "etaText": "12 min",
  "deliveryFeeText": null,
  "meta": [ { "text": "12 min", "accessibilityText": "Delivered in 12 to 23 min", "badgeType": "ETD" } ],
  "imageUrl": "https://tb-static.uber.com/prod/image-proc/.../268ee1a1296808aa6eae11eb597de84d.jpeg",
  "favorite": false,
  "endorsements": null,
  "signposts": null
}
```

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Restaurant name. |
| `url` | string | Link to the restaurant on UberEats. |
| `cityName` | string | Market the result belongs to. |
| `ratingText` | string | Star rating. |
| `etaText` | string | Estimated delivery time. |
| `deliveryFeeText` | string | Delivery fee, when shown. |
| `imageUrl` | string | Restaurant photo. |
| `endorsements` / `signposts` | array | Badges and current offers (e.g. "Great value", "20% off $15+"), when present. |

**Store mode** — one row per menu item (`itemsAsRows: true`):

```json
{
  "_input": "https://www.ubereats.com/store/ess-a-bagel-115-broadway/DxhTGkXoURuZAGDJWnguWA",
  "_scrapedAt": "2026-07-09T15:50:38Z",
  "_source": "S1-store",
  "recordType": "MENU_ITEM",
  "storeUuid": "0f18531a-45e8-511b-9900-60c95a782e58",
  "storeTitle": "Ess-a-Bagel (115 Broadway)",
  "storeUrl": "https://www.ubereats.com/store/ess-a-bagel-115-broadway/",
  "currencyCode": "USD",
  "storeRating": 4.7,
  "phoneNumber": "+16464750675",
  "priceBucket": "$",
  "isOpen": true,
  "cuisineList": ["American", "Breakfast and Brunch", "Desserts"],
  "address": "115 Broadway, New York, NY 10006",
  "city": "New York",
  "latitude": 40.708729,
  "longitude": -74.0110446,
  "categoryTitle": "Featured items",
  "itemUuid": "3ecbc6ff-9065-52b8-8885-d562a92ac762",
  "title": "Morning Classic",
  "itemDescription": "Your choice of bagel with bacon, egg, & American cheese",
  "price": 1208,
  "priceFormatted": 12.08,
  "priceText": "$12.08",
  "imageUrl": "https://tb-static.uber.com/prod/image-proc/.../d03e52b3c8af19d8fa8222e23efd9cfa.jpeg",
  "isSoldOut": false,
  "isAvailable": true,
  "hasCustomizations": true
}
```

| Field | Type | Description |
|-------|------|-------------|
| `storeTitle` / `storeUrl` | string | Restaurant name and link. |
| `currencyCode` | string | Currency of the prices. |
| `storeRating` | number | Restaurant star rating. |
| `phoneNumber` | string | Restaurant phone number. |
| `priceBucket` | string | Price level (`$`, `$$`, …). |
| `isOpen` | boolean | Whether the restaurant is currently open. |
| `cuisineList` | array | Cuisine tags. |
| `address` / `city` / `latitude` / `longitude` | string / number | Restaurant location. |
| `categoryTitle` | string | Menu section the item belongs to. |
| `title` | string | Menu item name. |
| `itemDescription` | string | Item description. |
| `price` | integer | Price in minor units (cents), e.g. `1208`. |
| `priceFormatted` | number | Price in major units, e.g. `12.08`. |
| `priceText` | string | Price as shown on the site (e.g. "Priced by add-ons"). |
| `isSoldOut` / `isAvailable` | boolean | Availability of the item. |
| `hasCustomizations` | boolean | Whether the item has add-on choices (captured when `includeModifiers` is on). |

With `itemsAsRows: false`, store mode instead emits one row per restaurant (`recordType: "STORE_MENU"`) with the full menu nested under `menuItems[]`.

On failure the actor writes a row with `_error` and `_errorDetail` rather than silently skipping.

### Notes & limits

- **US residential proxy is recommended** (and set by default) for reliable cloud runs; pick the country that matches your target market.
- **Menu availability varies by country and time of day** — a restaurant closed for the current daypart may return fewer items or an unavailable menu. Use a `localeCode` / `location` matching the target market.
- Prices are given both in minor units (`price`, e.g. cents) and major units (`priceFormatted`).

# Actor input Schema

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

feed = list stores near each location (getFeedV1). store = pull the full menu of specific stores (getStoreV1).

## `locations` (type: `array`):

feed mode only. Each entry is either an object {"latitude":40.71,"longitude":-74.0,"title":"New York"} or a "lat,lng" string. One request per location. Defaults to New York if empty.

## `includeMenus` (type: `boolean`):

feed mode only. If true, also fetch each nearby store's full menu (getStoreV1) after listing it. Much slower and more requests; leave off to only list stores.

## `stores` (type: `array`):

store mode only. Store URLs (https://www.ubereats.com/store/{slug}/{id}) or raw store IDs. The id in a store URL is resolved automatically.

## `itemsAsRows` (type: `boolean`):

store mode only. If true (default), emit one dataset record per menu ITEM (best for price monitoring). If false, emit one record per store with the menu nested inside.

## `includeModifiers` (type: `boolean`):

If true, enrich each menu item with its full nested modifier groups (customizationsList) via a per-item getMenuItemV1 call. Adds one request per customizable item, so it is slow. getStoreV1 alone only exposes a hasCustomizations flag.

## `location` (type: `object`):

store mode only, optional. A location near the store; provide {"latitude":..,"longitude":..,"title":..}. Defaults to New York, which works for most stores.

## `localeCode` (type: `string`):

Country / locale for the results. Use a country code like "us", "gb", "ca", or a full locale like "en-US". Menu availability and language vary by country and time of day.

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

Cap on total dataset records pushed across all locations/stores. 0 = no cap.

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

How many locations (feed) or stores (store) to process in parallel.

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

Proxy for outbound requests. UberEats is a real site with bot defense — US RESIDENTIAL is recommended for cloud runs. Datacenter proxies may work for the BFF but are riskier; residential is safer.

## Actor input object example

```json
{
  "mode": "feed",
  "locations": [
    {
      "latitude": 40.7128,
      "longitude": -74.006,
      "title": "New York"
    }
  ],
  "includeMenus": false,
  "stores": [
    "https://www.ubereats.com/store/ess-a-bagel-115-broadway/DxhTGkXoURuZAGDJWnguWA"
  ],
  "itemsAsRows": true,
  "includeModifiers": false,
  "location": {
    "latitude": 40.7128,
    "longitude": -74.006,
    "title": "New York"
  },
  "localeCode": "us",
  "maxItems": 0,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "locations": [
        {
            "latitude": 40.7128,
            "longitude": -74.006,
            "title": "New York"
        }
    ],
    "stores": [
        "https://www.ubereats.com/store/ess-a-bagel-115-broadway/DxhTGkXoURuZAGDJWnguWA"
    ],
    "location": {
        "latitude": 40.7128,
        "longitude": -74.006,
        "title": "New York"
    },
    "localeCode": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/ubereats-menu-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 = {
    "locations": [{
            "latitude": 40.7128,
            "longitude": -74.006,
            "title": "New York",
        }],
    "stores": ["https://www.ubereats.com/store/ess-a-bagel-115-broadway/DxhTGkXoURuZAGDJWnguWA"],
    "location": {
        "latitude": 40.7128,
        "longitude": -74.006,
        "title": "New York",
    },
    "localeCode": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("xtracto/ubereats-menu-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 '{
  "locations": [
    {
      "latitude": 40.7128,
      "longitude": -74.006,
      "title": "New York"
    }
  ],
  "stores": [
    "https://www.ubereats.com/store/ess-a-bagel-115-broadway/DxhTGkXoURuZAGDJWnguWA"
  ],
  "location": {
    "latitude": 40.7128,
    "longitude": -74.006,
    "title": "New York"
  },
  "localeCode": "us"
}' |
apify call xtracto/ubereats-menu-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UberEats Menu Scraper",
        "description": "Scrape UberEats: list restaurants near a location (lat/lng) and pull a store's full menu — items, prices, descriptions, and modifier groups. Feed and store modes; one row per menu item for price monitoring.",
        "version": "0.1",
        "x-build-id": "DUNYBpq6SYlVaTAxP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~ubereats-menu-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-ubereats-menu-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/xtracto~ubereats-menu-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-ubereats-menu-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/xtracto~ubereats-menu-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-ubereats-menu-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "feed",
                            "store"
                        ],
                        "type": "string",
                        "description": "feed = list stores near each location (getFeedV1). store = pull the full menu of specific stores (getStoreV1).",
                        "default": "feed"
                    },
                    "locations": {
                        "title": "Locations (feed mode)",
                        "type": "array",
                        "description": "feed mode only. Each entry is either an object {\"latitude\":40.71,\"longitude\":-74.0,\"title\":\"New York\"} or a \"lat,lng\" string. One request per location. Defaults to New York if empty.",
                        "default": []
                    },
                    "includeMenus": {
                        "title": "Include menus (feed mode)",
                        "type": "boolean",
                        "description": "feed mode only. If true, also fetch each nearby store's full menu (getStoreV1) after listing it. Much slower and more requests; leave off to only list stores.",
                        "default": false
                    },
                    "stores": {
                        "title": "Stores (store mode)",
                        "type": "array",
                        "description": "store mode only. Store URLs (https://www.ubereats.com/store/{slug}/{id}) or raw store IDs. The id in a store URL is resolved automatically.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "itemsAsRows": {
                        "title": "One row per menu item (store mode)",
                        "type": "boolean",
                        "description": "store mode only. If true (default), emit one dataset record per menu ITEM (best for price monitoring). If false, emit one record per store with the menu nested inside.",
                        "default": true
                    },
                    "includeModifiers": {
                        "title": "Include modifiers / customizations",
                        "type": "boolean",
                        "description": "If true, enrich each menu item with its full nested modifier groups (customizationsList) via a per-item getMenuItemV1 call. Adds one request per customizable item, so it is slow. getStoreV1 alone only exposes a hasCustomizations flag.",
                        "default": false
                    },
                    "location": {
                        "title": "Location cookie (store mode)",
                        "type": "object",
                        "description": "store mode only, optional. A location near the store; provide {\"latitude\":..,\"longitude\":..,\"title\":..}. Defaults to New York, which works for most stores.",
                        "default": {}
                    },
                    "localeCode": {
                        "title": "Locale / country code",
                        "type": "string",
                        "description": "Country / locale for the results. Use a country code like \"us\", \"gb\", \"ca\", or a full locale like \"en-US\". Menu availability and language vary by country and time of day.",
                        "default": "us"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on total dataset records pushed across all locations/stores. 0 = no cap.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent workers",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many locations (feed) or stores (store) to process in parallel.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy for outbound requests. UberEats is a real site with bot defense — US RESIDENTIAL is recommended for cloud runs. Datacenter proxies may work for the BFF but are riskier; residential is safer.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
