# MenuPages Restaurant Menu Scraper (`automation-lab/menupages-restaurant-menu-scraper`) Actor

🍽️ Extract public MenuPages menus, item prices, descriptions, cuisine, address, coordinates, and phone details. Batch URLs, schedule monitoring, and export structured data.

- **URL**: https://apify.com/automation-lab/menupages-restaurant-menu-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

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

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

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

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

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

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

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

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


# README

## MenuPages Restaurant Menu Scraper

Turn public MenuPages restaurant pages into analysis-ready menu and price data.

Provide one restaurant URL or a batch of URLs. The Actor returns one row per unique menu item, enriched with restaurant identity, cuisine, address, coordinates, phone number, image, and source information.

Use the output in spreadsheets, databases, BI tools, catalogs, or scheduled price-monitoring workflows.

### What does MenuPages Restaurant Menu Scraper do?

MenuPages Restaurant Menu Scraper extracts server-rendered restaurant and menu data from public `menupages.com` restaurant pages.

It collects:

- 🍽️ restaurant name and cuisine categories
- 📍 street address, city, region, postal code, and country
- 🗺️ latitude and longitude
- ☎️ telephone number
- 🖼️ restaurant image and canonical URL
- 📋 menu section and stable item ID
- 🥘 menu item name and available description or ingredients
- 💵 displayed price, normalized numeric price, and currency
- 🔗 source URL and extraction timestamp

Repeated entries, such as items shown in both “Most Popular” and their normal section, are deduplicated using the restaurant URL and MenuPages item ID.

### Who is it for?

#### Restaurant chains and operators

Compare menus and public prices across nearby restaurants or markets.

#### Food-data vendors

Build structured menu feeds without manually copying restaurant pages.

#### Pricing and competitive-intelligence teams

Schedule repeat runs, compare snapshots, and identify price or assortment changes.

#### Analysts and researchers

Export normalized menu records to CSV, Excel, JSON, or a database.

#### Developers

Call the Actor through the Apify API and connect results to internal applications.

### Why use this MenuPages scraper?

Manual menu collection is slow and inconsistent. A single restaurant may have dozens or hundreds of items, repeated promotional sections, and prices embedded in page markup.

This Actor provides:

- structured rows ready for filtering and joins
- batch processing of multiple restaurant URLs
- deterministic duplicate removal
- both raw and normalized price values
- per-URL errors for stale or unavailable pages
- optional Apify Proxy support for transient access problems
- pay-per-event billing tied to actual saved menu items

### What data can you extract?

| Field | Type | Description |
|---|---|---|
| `status` | string | `success` for menu rows or `error` for failed URLs |
| `restaurantName` | string | Restaurant name from structured page data |
| `cuisines` | array | Cuisine and meal categories |
| `streetAddress` | string | Street address |
| `locality` | string | City or locality |
| `region` | string | State or region |
| `postalCode` | string | Postal code |
| `country` | string | Country code or name |
| `latitude` | number | Restaurant latitude |
| `longitude` | number | Restaurant longitude |
| `telephone` | string | Public telephone number |
| `restaurantImageUrl` | string | Restaurant image URL |
| `canonicalUrl` | string | Canonical MenuPages restaurant URL |
| `itemId` | string | Stable MenuPages item identifier |
| `section` | string | Menu section name |
| `itemName` | string | Menu item name |
| `description` | string | Available description or ingredients |
| `rawPrice` | string | Price exactly as displayed |
| `price` | number | Normalized numeric price |
| `currency` | string | Detected currency, usually `USD` |
| `sourceUrl` | string | Requested restaurant page |
| `scrapedAt` | string | ISO 8601 extraction timestamp |
| `error` | string | Explanation for a failed source URL |

### How to scrape MenuPages restaurant menus

1. Open the Actor input page.
2. Add one or more public MenuPages restaurant URLs.
3. Choose the maximum number of unique items per restaurant.
4. Leave proxy configuration empty for the normal direct-HTTP route.
5. Click **Start**.
6. Review the dataset while the run is executing.
7. Export results as JSON, CSV, Excel, XML, or another supported format.

A small first run is recommended before processing a larger restaurant list.

### Input

```json
{
  "startUrls": [
    { "url": "https://menupages.com/pings/22-mott-street-new-york" }
  ],
  "maxItemsPerRestaurant": 200
}
````

#### `startUrls`

Required array of exact public MenuPages restaurant-detail URLs.

Only HTTPS URLs on `menupages.com` are accepted. Search pages, unrelated domains, and malformed paths fail closed instead of returning misleading output.

#### `maxItemsPerRestaurant`

Optional integer from 1 to 5,000.

The default is 200. The limit applies after item-ID deduplication and independently to each restaurant.

#### `proxyConfiguration`

Optional standard Apify Proxy configuration.

Most public pages work without a proxy. Configure a proxy only when direct access is transiently blocked or a workflow requires a particular proxy policy.

### Output example

```json
{
  "status": "success",
  "restaurantName": "Pings",
  "cuisines": ["Asian", "Chinese", "Dinner", "Lunch Specials"],
  "streetAddress": "22 Mott Street",
  "locality": "New York",
  "region": "NY",
  "postalCode": "10013-5001",
  "country": "US",
  "latitude": 40.71439,
  "longitude": -73.99878,
  "telephone": "+12126029988",
  "canonicalUrl": "https://menupages.com/pings/22-mott-street-new-york",
  "itemId": "21889802",
  "section": "Most Popular",
  "itemName": "Pings signature BBQ Roast Pork",
  "rawPrice": "$22.95",
  "price": 22.95,
  "currency": "USD",
  "sourceUrl": "https://menupages.com/pings/22-mott-street-new-york",
  "scrapedAt": "2026-07-17T12:00:00.000Z"
}
```

Optional fields are omitted when MenuPages does not publish them.

### Batch restaurant extraction

Add several URLs to `startUrls` to create a single tabular dataset across restaurants.

Each row repeats the relevant restaurant metadata. This makes CSV exports self-contained and avoids a second lookup table.

Duplicate input URLs are normalized and processed once per run.

### Menu item deduplication

MenuPages may repeat an item in a promotional section such as “Most Popular” and in its regular category.

The Actor keeps the first observed instance for each canonical restaurant URL plus item ID.

This prevents repeated items from inflating exports or PPE charges.

Items without an HTML item ID use a deterministic section-and-name fallback.

### Price normalization

`rawPrice` preserves the text shown on MenuPages.

`price` extracts a numeric value suitable for sorting, calculations, and comparisons.

`currency` is set to `USD` when the displayed value uses a dollar sign.

If no usable price is shown, price fields are omitted rather than invented.

### How much does it cost to scrape MenuPages menus?

The Actor uses pay-per-event pricing:

- one **Run started** charge of $0.005 per run
- one **Menu item extracted** charge per unique saved menu item

| Apify tier | Price per menu item |
|---|---:|
| Free | $0.000029074 |
| Bronze | $0.000025282 |
| Silver | $0.00001972 |
| Gold | $0.000015169 |
| Platinum | $0.000010113 |
| Diamond | $0.00001 |

At the Bronze rate, 1,000 unique menu items cost about $0.0253 plus the single $0.005 start charge.

Failed URL status rows are not charged as extracted menu items.

For the best value, batch multiple restaurant URLs into one run so the one-time start cost is shared.

### Scheduling menu and price monitoring

Apify schedules can run the Actor daily, weekly, or at another interval.

A typical monitoring workflow is:

1. keep a stable list of competitor restaurant URLs
2. run the Actor on a schedule
3. export each run to a timestamped dataset or external database
4. compare records by `canonicalUrl` and `itemId`
5. alert when `price`, `itemName`, or section membership changes

The Actor returns `scrapedAt` on every row to support snapshot comparisons.

### Integrations

#### Google Sheets

Use an Apify integration or automation platform to append each scheduled dataset to a sheet used by pricing analysts.

#### Webhooks

Send a webhook when a run finishes, then fetch the default dataset from your own application.

#### Make and Zapier

Trigger downstream workflows for menu enrichment, competitor tracking, or data delivery.

#### Cloud storage and databases

Export JSON or CSV into Amazon S3, Google Drive, PostgreSQL, BigQuery, Snowflake, or your preferred warehouse through Apify integrations or API code.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/menupages-restaurant-menu-scraper').call({
  startUrls: [
    { url: 'https://menupages.com/pings/22-mott-street-new-york' }
  ],
  maxItemsPerRestaurant: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/menupages-restaurant-menu-scraper').call(run_input={
    'startUrls': [
        {'url': 'https://menupages.com/pings/22-mott-street-new-york'}
    ],
    'maxItemsPerRestaurant': 200,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~menupages-restaurant-menu-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [
      {"url": "https://menupages.com/pings/22-mott-street-new-york"}
    ],
    "maxItemsPerRestaurant": 200
  }'
```

Use the returned run ID to inspect status and retrieve the default dataset.

### Use with Apify MCP and AI agents

#### Claude Code setup

Add Apify MCP over HTTP with the Actor preselected:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/menupages-restaurant-menu-scraper"
```

#### Claude Desktop setup

Add this entry to the `mcpServers` object in the Claude Desktop configuration:

```json
{
  "mcpServers": {
    "apify-menupages": {
      "url": "https://mcp.apify.com/?tools=automation-lab/menupages-restaurant-menu-scraper"
    }
  }
}
```

#### Cursor setup

Add the same `mcpServers` JSON to Cursor’s MCP configuration, or add the HTTP server URL through **Settings → MCP**.

#### VS Code setup

Open the MCP server configuration in VS Code and add the Apify HTTP endpoint shown above. Authenticate with your Apify account when prompted.

Specific example prompts:

- “Extract the first 100 menu items from this MenuPages restaurant and group them by section.”
- “Compare normalized prices for these three MenuPages restaurants.”
- “Run the MenuPages competitor menu monitor and flag items whose price changed since yesterday.”

### Error handling

When one URL fails, the Actor writes an explicit dataset row containing:

```json
{
  "status": "error",
  "sourceUrl": "https://menupages.com/example/missing-location",
  "error": "MenuPages returned HTTP 404.",
  "scrapedAt": "2026-07-17T12:00:00.000Z"
}
```

Other valid URLs in the same batch continue processing.

If every requested URL fails, the run ends with a failed status after writing the error rows. This prevents empty or broken extraction from looking successful.

### Tips for reliable runs

- Use exact restaurant-detail URLs copied from MenuPages.
- Keep the initial prefilled limit small for a quick validation run.
- Increase `maxItemsPerRestaurant` when you need the full menu.
- Batch URLs to reduce repeated start charges.
- Schedule snapshots at a consistent time for easier comparisons.
- Match records using `canonicalUrl` plus `itemId`.
- Inspect error rows before retrying stale restaurant URLs.
- Enable a proxy only after direct access shows a repeatable block.

### Limitations

The Actor extracts data that MenuPages publishes on public restaurant pages at run time.

It does not discover restaurants by keyword, city, or cuisine in the current version; provide exact restaurant URLs.

It does not place orders, log into accounts, or collect private information.

Descriptions and prices may be absent for some items because the source page does not provide them.

MenuPages can change its HTML structure or remove stale restaurant pages. Clear error rows and failed-all behavior make those changes visible.

### Is it legal to scrape MenuPages?

This Actor accesses public web pages and does not bypass login controls.

You are responsible for ensuring that your use complies with applicable laws, contractual obligations, website terms, and data-protection requirements.

Avoid collecting or using data in ways that infringe rights or create harmful outcomes. Use conservative schedules and reasonable batch sizes.

This documentation is informational and is not legal advice.

### Troubleshooting

#### Why did my URL produce an error row?

Confirm that it is an HTTPS MenuPages restaurant-detail URL with both a restaurant slug and a location slug. Open it manually to check whether the restaurant still exists.

#### Why are some descriptions or prices missing?

MenuPages does not publish those values for every menu item. The Actor omits missing fields instead of guessing.

#### Why are there fewer rows than visible item placements?

The same item can appear in more than one section. The Actor intentionally deduplicates repeated MenuPages item IDs.

#### Why did the entire run fail?

The run fails when every requested restaurant fails extraction. Read the dataset error rows and logs, then update stale URLs or try an appropriate proxy configuration.

#### Can I scrape non-MenuPages websites?

No. Domain validation is intentionally strict. Use an actor designed for that source.

### FAQ

#### Can I process multiple restaurants in one run?

Yes. Add every restaurant URL to `startUrls`. Each valid restaurant is processed independently.

#### Does it support scheduled price tracking?

Yes. Combine Apify schedules with dataset exports or webhooks and compare records by `canonicalUrl` and `itemId`.

#### Are repeated “Most Popular” entries charged twice?

No. Repeated stable item IDs are removed before output and charging.

#### Does it need a browser?

No. The useful restaurant and menu data is server-rendered, so the Actor uses a lightweight HTTP and Cheerio implementation.

#### Does it need a proxy?

Not normally. Proxy configuration is optional for transient blocking or organization-specific routing policies.

#### What export formats are available?

Apify datasets support JSON, JSONL, CSV, Excel, XML, RSS, and other formats.

### Related restaurant data actors

- [Grubhub Restaurant Menus Scraper](https://apify.com/automation-lab/grubhub-restaurant-menus-scraper) — scrape Grubhub restaurant listings and menu items.
- [DoorDash Scraper](https://apify.com/automation-lab/doordash-scraper) — collect restaurant and delivery marketplace data from DoorDash.
- [Google Maps Scraper](https://apify.com/automation-lab/google-maps-scraper) — discover restaurants and other places before sending exact URLs to source-specific workflows.

Choose this Actor when the source records you need are public MenuPages restaurant pages.

### Support

If a valid public MenuPages restaurant URL stops working, open an issue from the Actor page and include:

- the source URL
- the run ID
- the expected result
- the actual error or missing field

A reproducible example helps us adapt quickly when the source changes.

# Actor input Schema

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

One or more public MenuPages restaurant detail URLs, for example https://menupages.com/pings/22-mott-street-new-york.

## `maxItemsPerRestaurant` (type: `integer`):

Stop after this many unique menu items for each restaurant. Repeated Most Popular items are deduplicated before counting.

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

Optional Apify Proxy settings for transient blocks or location-specific access. Direct requests are used when omitted.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://menupages.com/pings/22-mott-street-new-york"
    }
  ],
  "maxItemsPerRestaurant": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://menupages.com/pings/22-mott-street-new-york"
        }
    ],
    "maxItemsPerRestaurant": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/menupages-restaurant-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 = {
    "startUrls": [{ "url": "https://menupages.com/pings/22-mott-street-new-york" }],
    "maxItemsPerRestaurant": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/menupages-restaurant-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 '{
  "startUrls": [
    {
      "url": "https://menupages.com/pings/22-mott-street-new-york"
    }
  ],
  "maxItemsPerRestaurant": 20
}' |
apify call automation-lab/menupages-restaurant-menu-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MenuPages Restaurant Menu Scraper",
        "description": "🍽️ Extract public MenuPages menus, item prices, descriptions, cuisine, address, coordinates, and phone details. Batch URLs, schedule monitoring, and export structured data.",
        "version": "0.1",
        "x-build-id": "NxNmfNyPv6csRe40y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~menupages-restaurant-menu-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-menupages-restaurant-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/automation-lab~menupages-restaurant-menu-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-menupages-restaurant-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/automation-lab~menupages-restaurant-menu-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-menupages-restaurant-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🍽️ MenuPages restaurant URLs",
                        "type": "array",
                        "description": "One or more public MenuPages restaurant detail URLs, for example https://menupages.com/pings/22-mott-street-new-york.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItemsPerRestaurant": {
                        "title": "Maximum menu items per restaurant",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many unique menu items for each restaurant. Repeated Most Popular items are deduplicated before counting.",
                        "default": 200
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings for transient blocks or location-specific access. Direct requests are used when omitted."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```