# Food Delivery Scraper (`e-commerce/food-delivery-scraper`) Actor

Scrape restaurant listings, full menus, prices, and reviews from Wolt, Glovo, Deliveroo, Just Eat, DoorDash, and Instacart by URL, keyword, or delivery address. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/e-commerce/food-delivery-scraper.md
- **Developed by:** [E Commerce](https://apify.com/e-commerce) (Apify)
- **Categories:** E-commerce
- **Stats:** 5 total users, 2 monthly users, 70.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 menu items

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Food Delivery Scraper

Food Delivery Scraper collects restaurant listings, full menus with prices, and customer reviews from six major food delivery platforms: Wolt, Glovo, Deliveroo, Just Eat, DoorDash, and Instacart. Give it a listing URL, a restaurant URL, a keyword, or a delivery address, and it returns structured records: dish `name`, `offers.price`, `image`, `description`, restaurant `rating`, `address`, delivery time, and review text with author and date. No login, no manual copy-paste.

![Food Delivery Scraper: menus, prices, and reviews from six delivery platforms](https://raw.githubusercontent.com/luispintoapify/apify-actor-readme-images/main/food-delivery-scraper-overview.png)

### What does Food Delivery Scraper do?

- Extracts **restaurant listings**: name, URL, rating, cuisine, and location.
- Pulls **complete menus**: every category, dish, description, price, and photo.
- Collects **customer reviews**: author, date, rating, and full text on Deliveroo and Just Eat.
- Runs three output modes: **menu items**, **restaurants (sellers)**, or **reviews**, all joinable on the restaurant URL.
- Accepts **four input types**: listing URLs, restaurant URLs, keyword search, or delivery address.
- Returns clean JSON, ready to export to CSV, Excel, JSON, or Google Sheets.

### Which food delivery platforms does it support?

| Platform | Listings | Menus | Reviews |
|---|---|---|---|
| Wolt | ✅ | ✅ | Aggregate rating only |
| Glovo | ✅ | ✅ | Aggregate rating only |
| Deliveroo | ✅ | ✅ | ✅ Full review text |
| Just Eat (UK) | ✅ | ✅ | ✅ Full review text |
| DoorDash | ✅ (keyword) | ✅ | Not available |
| Instacart | ✅ (keyword) | ✅ | Not available |

Wolt and Glovo do not publish individual review text, so an aggregate rating and rating count are returned with the restaurant and menu data instead.

![Sample menu-item output with name, price, category, restaurant, and rating](https://raw.githubusercontent.com/luispintoapify/apify-actor-readme-images/main/food-delivery-scraper-output-menu.png)

### Why scrape food delivery data?

- **Menu price monitoring**: track how competitors price the same dish across cities and platforms.
- **Market research**: map restaurant density, cuisine mix, and ratings for a delivery area before you expand.
- **Menu intelligence**: see which dishes, categories, and price points dominate a market.
- **Review analysis**: pull thousands of reviews to surface recurring complaints or standout items.
- **Aggregator building**: power a comparison site or dashboard with fresh menu and rating data.

### How do I scrape food delivery data?

1. Open Food Delivery Scraper and click **Try for free**.
2. Choose your input: paste **Delivery listing URLs** for a whole area, add **Restaurant detail URLs** for specific venues, or type a **Keyword** with a **Delivery address**.
3. Pick **What to scrape**: Menu items, Restaurants (sellers), or Reviews.
4. Set **Total maximum results** to cap run time and cost.
5. Click **Start**, then export the dataset as CSV, JSON, or Excel when the run finishes.

![Food Delivery Scraper input panel](https://raw.githubusercontent.com/luispintoapify/apify-actor-readme-images/main/food-delivery-scraper-input.png)

### What input does Food Delivery Scraper accept?

| Field | Type | What it does |
|---|---|---|
| Delivery listing URLs | Array | Area or category pages. Scrapes every restaurant found on them. |
| Restaurant detail URLs | Array | Individual restaurant pages with full menu and metadata. |
| Keyword for search | String | Finds dishes across the selected marketplaces. |
| Marketplaces for keyword search | Array | Which platforms the keyword runs against. |
| Delivery address or location | String | Localizes keyword results (city, ZIP, or address). |
| What to scrape | Select | Menu items, Restaurants (sellers), or Reviews. |
| Total maximum results | Integer | Caps the total items collected. |

Example input for a keyword search:

```json
{
  "keywordDelivery": "sushi",
  "marketplacesDelivery": ["www.doordash.com", "deliveroo.co.uk"],
  "addressDelivery": "New York",
  "scrapeModeDelivery": "Menu items",
  "maxDeliveryResults": 200
}
````

To scrape a whole delivery area instead, drop the listing URL into `deliveryListingUrls` and set `scrapeModeDelivery` to `Restaurants (sellers)`.

### What data does Food Delivery Scraper extract?

Menu items and restaurants follow a product schema, and reviews follow a review schema. Everything joins on the restaurant `url`.

| Field | Description |
|---|---|
| `url` | Restaurant or dish page URL |
| `name` | Dish or restaurant name |
| `offers.price` | Item price with currency |
| `image` | Dish or restaurant image URL |
| `description` | Dish or restaurant description |
| `additionalProperties` | Menu, cuisine, delivery time, minimum order, coordinates |
| `aggregateRating` | Rating value and review count |
| `author`, `datePublished`, `reviewBody`, `reviewRating` | Review fields |

Sample menu-item output:

```json
{
  "url": "https://deliveroo.co.uk/menu/london/soho/pizza-pilgrims",
  "name": "Margherita",
  "offers": { "price": 9.5, "priceCurrency": "GBP" },
  "image": "https://.../margherita.jpg",
  "description": "San Marzano tomato, fior di latte, basil",
  "additionalProperties": { "category": "Pizza", "restaurantRating": 4.7 }
}
```

![Sample review output with author, date, rating, and review text](https://raw.githubusercontent.com/luispintoapify/apify-actor-readme-images/main/food-delivery-scraper-output-reviews.png)

### How do I run the scraper via API or schedule it?

Every run is available through the Apify API. Start a run and fetch results in a few lines:

```bash
curl -X POST "https://api.apify.com/v2/acts/e-commerce~food-delivery-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "keywordDelivery": "pizza", "addressDelivery": "Berlin", "maxDeliveryResults": 100 }'
```

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('e-commerce/food-delivery-scraper').call({
  keywordDelivery: 'pizza',
  addressDelivery: 'Berlin',
  maxDeliveryResults: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Use the **Schedules** tab to run the scraper hourly, daily, or weekly, and connect **webhooks** or integrations such as Google Sheets, Make, Zapier, and Slack to push fresh data wherever you need it.

![Run on a schedule and push data to integrations](https://raw.githubusercontent.com/luispintoapify/apify-actor-readme-images/main/food-delivery-scraper-schedule.png)

### How much does it cost to scrape food delivery data?

Food Delivery Scraper uses a pay-per-event pricing model: you pay for the results you collect, platform usage is included, and there is no monthly rental fee. Start on the free tier, then use **Total maximum results** to keep any run within budget.

![Pay-per-event pricing](https://raw.githubusercontent.com/luispintoapify/apify-actor-readme-images/main/food-delivery-scraper-pricing.png)

### Troubleshooting: common issues and solutions

| Issue | Solution |
|---|---|
| No results found | Widen the keyword (for example, "burger" instead of "double bacon burger"), or confirm the platform delivers to your address. |
| Keyword search returns 0 items | Set a **Delivery address** and select at least one marketplace. |
| Reviews are empty | Review text is available only on Deliveroo and Just Eat. Other platforms return an aggregate rating. |
| Run takes too long | Lower **Total maximum results**, or scrape fewer listing URLs per run. |
| Prices missing on some items | A few restaurants hide prices until checkout, so those items return without `offers.price`. |
| Wrong city or currency | Match the URL region (for example, `deliveroo.fr`) or the address to the market you want. |

![Export results as JSON, CSV, Excel, or Google Sheets, or through the API](https://raw.githubusercontent.com/luispintoapify/apify-actor-readme-images/main/food-delivery-scraper-export.png)

### Is it legal to scrape food delivery platforms?

Scraping publicly available data (restaurant listings, menus, prices, and public reviews) is legal in most jurisdictions. This scraper collects only public information and never accesses private accounts. You are responsible for how you use the data, so review each platform's terms and applicable laws such as GDPR before scraping personal data like reviewer names.

### Frequently asked questions

**Which platforms can I scrape?** Wolt, Glovo, Deliveroo, Just Eat (UK), DoorDash, and Instacart. Deliveroo and Just Eat return full review text, and the others return aggregate ratings.

**Can I scrape a whole city at once?** Yes. Paste the area listing URLs and choose "Restaurants (sellers)" for every venue, or "Menu items" for every dish.

**Do I need to log in or provide cookies?** No. The scraper works with public pages only.

**Can I use this scraper with the API?** Yes. Start runs and fetch datasets through the Apify API or the JavaScript and Python clients shown above.

**Does it work with the Apify MCP server?** Yes. The Actor is available through the Apify MCP server, so AI agents and assistants like Claude can call it directly and receive structured data.

**What formats can I export?** JSON, CSV, Excel, HTML, or Google Sheets, plus webhooks and Make or Zapier integrations.

**How fresh is the data?** Every run scrapes live pages, so results reflect current menus, prices, and reviews.

### Changelog

- Added a scrape-mode selector: choose Menu items, Restaurants (sellers), or Reviews.
- Added Just Eat menu prices with per-item currency handling.
- Consolidated the menu-item address into a single full-address field.

### Feedback

Found a bug or need another platform? Open an issue on the Actor's **Issues** tab. Feature requests help shape the roadmap.

# Actor input Schema

## `deliveryListingUrls` (type: `array`):

Category or area listing pages to crawl. Every restaurant found on each page is scraped automatically. Paste one URL per line. Examples: 'https://wolt.com/en/de/berlin/restaurants', 'https://deliveroo.co.uk/restaurants/london/soho', 'https://www.just-eat.co.uk/area/sw1a1aa'. Leave empty if you are using restaurant detail URLs or keyword search instead.

## `deliveryDetailsUrls` (type: `array`):

Direct links to individual restaurant pages. Each URL is scraped separately to return the full menu (categories, dishes, prices, images), restaurant metadata, and reviews where available. Examples: 'https://deliveroo.co.uk/menu/london/soho/pizza-pilgrims', 'https://www.just-eat.co.uk/restaurants-example/menu'. Leave empty if you are using listing URLs or keyword search.

## `keywordDelivery` (type: `string`):

Search term used to find dishes and products across the marketplaces you select below. Requires a delivery address so results can be localized. Examples: 'sushi', 'vegan burger', 'pad thai', 'ice cream'. Leave empty if you are scraping by URL.

## `marketplacesDelivery` (type: `array`):

Which delivery marketplaces the keyword search runs against. Only applies when 'Keyword for search' is set. Select one or more. Examples: 'www.doordash.com', 'www.instacart.com', 'deliveroo.co.uk'. Default behavior: if left empty, no keyword search is performed.

## `addressDelivery` (type: `string`):

Delivery location used to localize availability and pricing for keyword search. Accepts a city, ZIP/postal code, or full street address. Examples: 'New York', '10001', 'Berlin, Germany', '221B Baker Street, London'. Required for keyword search; ignored when scraping by URL.

## `scrapeModeDelivery` (type: `string`):

What each run returns. 'Menu items' = one row per dish (name, price, description, image). 'Restaurants (sellers)' = one record per venue (rating, address, delivery time, cuisine). 'Reviews' = one row per customer review. All three join on the restaurant URL. Default: 'Menu items'.

## `maxDeliveryResults` (type: `integer`):

Caps the total number of items (menu items, restaurants, or reviews) collected across the whole run. Use it to control run time and cost. Examples: 50 for a quick test, 1000 for a full area sweep. Default behavior: if left empty, the run collects all available results.

## Actor input object example

```json
{
  "scrapeModeDelivery": "Menu items"
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("e-commerce/food-delivery-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("e-commerce/food-delivery-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 '{}' |
apify call e-commerce/food-delivery-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Food Delivery Scraper",
        "description": "Scrape restaurant listings, full menus, prices, and reviews from Wolt, Glovo, Deliveroo, Just Eat, DoorDash, and Instacart by URL, keyword, or delivery address. Export data, run via API, schedule and monitor runs, or integrate with other tools.",
        "version": "0.1",
        "x-build-id": "DaliizhY0I7mczaHM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/e-commerce~food-delivery-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-e-commerce-food-delivery-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/e-commerce~food-delivery-scraper/runs": {
            "post": {
                "operationId": "runs-sync-e-commerce-food-delivery-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/e-commerce~food-delivery-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-e-commerce-food-delivery-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": {
                    "deliveryListingUrls": {
                        "title": "🔗 Delivery listing URLs",
                        "type": "array",
                        "description": "Category or area listing pages to crawl. Every restaurant found on each page is scraped automatically. Paste one URL per line. Examples: 'https://wolt.com/en/de/berlin/restaurants', 'https://deliveroo.co.uk/restaurants/london/soho', 'https://www.just-eat.co.uk/area/sw1a1aa'. Leave empty if you are using restaurant detail URLs or keyword search instead.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "deliveryDetailsUrls": {
                        "title": "🍽️ Restaurant detail URLs",
                        "type": "array",
                        "description": "Direct links to individual restaurant pages. Each URL is scraped separately to return the full menu (categories, dishes, prices, images), restaurant metadata, and reviews where available. Examples: 'https://deliveroo.co.uk/menu/london/soho/pizza-pilgrims', 'https://www.just-eat.co.uk/restaurants-example/menu'. Leave empty if you are using listing URLs or keyword search.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keywordDelivery": {
                        "title": "🔍 Keyword for search",
                        "type": "string",
                        "description": "Search term used to find dishes and products across the marketplaces you select below. Requires a delivery address so results can be localized. Examples: 'sushi', 'vegan burger', 'pad thai', 'ice cream'. Leave empty if you are scraping by URL."
                    },
                    "marketplacesDelivery": {
                        "title": "🛒 Marketplaces for keyword search",
                        "type": "array",
                        "description": "Which delivery marketplaces the keyword search runs against. Only applies when 'Keyword for search' is set. Select one or more. Examples: 'www.doordash.com', 'www.instacart.com', 'deliveroo.co.uk'. Default behavior: if left empty, no keyword search is performed.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "www.instacart.com",
                                "www.doordash.com",
                                "wolt.com",
                                "glovoapp.com",
                                "deliveroo.co.uk",
                                "deliveroo.fr",
                                "deliveroo.ie",
                                "deliveroo.nl",
                                "deliveroo.be",
                                "deliveroo.it"
                            ]
                        }
                    },
                    "addressDelivery": {
                        "title": "📍 Delivery address or location",
                        "type": "string",
                        "description": "Delivery location used to localize availability and pricing for keyword search. Accepts a city, ZIP/postal code, or full street address. Examples: 'New York', '10001', 'Berlin, Germany', '221B Baker Street, London'. Required for keyword search; ignored when scraping by URL."
                    },
                    "scrapeModeDelivery": {
                        "title": "🎯 What to scrape",
                        "enum": [
                            "Menu items",
                            "Restaurants (sellers)",
                            "Reviews"
                        ],
                        "type": "string",
                        "description": "What each run returns. 'Menu items' = one row per dish (name, price, description, image). 'Restaurants (sellers)' = one record per venue (rating, address, delivery time, cuisine). 'Reviews' = one row per customer review. All three join on the restaurant URL. Default: 'Menu items'.",
                        "default": "Menu items"
                    },
                    "maxDeliveryResults": {
                        "title": "🔢 Total maximum results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Caps the total number of items (menu items, restaurants, or reviews) collected across the whole run. Use it to control run time and cost. Examples: 50 for a quick test, 1000 for a full area sweep. Default behavior: if left empty, the run collects all available results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
