# Uber Eats Restaurant Scraper (`jdtpnjtp/uber-eats-restaurant-scraper`) Actor

Scrape Uber Eats restaurants and menus by city, search, or store URL. Extract restaurant name, rating, cuisine, address, delivery fee, menu items, prices, and reviews as clean JSON. Pay per result.

- **URL**: https://apify.com/jdtpnjtp/uber-eats-restaurant-scraper.md
- **Developed by:** [Data Forge](https://apify.com/jdtpnjtp) (community)
- **Categories:** Developer tools, E-commerce, Automation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 restaurant details

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

## Uber Eats Restaurant Scraper

Scrape Uber Eats restaurants and menus by city, search, or store URL. **Restaurants from $1.50 / 1,000 results.** Scrape a whole city's restaurants and menus in one run - restaurant name, rating, cuisine, address, menu items, prices, and reviews, exported as clean JSON, CSV, or Excel. Pay per result, no subscription.

### Why this Actor?

| Capability | This Actor | Typical competitors |
|---|---|---|
| Full restaurant menus | **60-131 items each, with prices, photos, and dietary flags** | Not included, or charged as an add-on |
| Restaurant fields | **17+ per restaurant (rating, cuisine, ETA, geo, phone, hours)** | Fewer, listing-only fields |
| City coverage | **Search plus whole-city listing, up to 200 restaurants per run** | Single search page |
| Result sorting | **Rating, recommended, or earliest arrival** | Default order only |
| Reviews | **Optional, up to 100 per restaurant** | Not available |
| Input flexibility | **Store URL, bare slug, restaurant name, or city plus search** | One input mode |
| Pricing | **Pay per result, from $1.50 / 1,000** | Monthly subscription |

### What does the Uber Eats Restaurant Scraper do?

The Uber Eats Restaurant Scraper turns Uber Eats listings into structured data. Point it at a city and a search term ("pizza", "sushi", "vegan"), or drop in store URLs, and it returns restaurant listings, complete restaurant profiles, the menu behind each restaurant (sections, items, prices, photos, dietary labels), and optional reviews.

It runs at market scale: pull one restaurant, a search result page, or a whole city's restaurant landscape in a single run. Rows come back as flat JSON with consistent columns, ready for spreadsheets, dashboards, or an AI pipeline. You pay per result, so a test costs cents and a sweep stays predictable.

### What data can you get from Uber Eats?

**Restaurant fields**

- Name, store slug, and Uber store UUID
- Average rating and review count
- Cuisine categories and price level ($ to $$$$)
- Address, latitude, and longitude
- Phone number
- Delivery time estimate (ETA min and max)
- Open-now status and opening hours
- Restaurant image and promoted/sponsored flag

**Menu fields (per restaurant)**

- Menu section and item counts
- Menu sections with their items
- Per item: name, description, price, photo, and dietary labels

**Review fields (optional)**

- Reviewer name, star rating, review text, and date

The menu structure is nested under the `data.menu` field on each restaurant detail row, so you keep flat columns for analysis and the rich object for deep dives.

### How to scrape Uber Eats

1. Open the actor. The input form comes prefilled with example values, so you can add a city or store URL and press **Start**.
2. To target specific restaurants, paste Uber Eats store URLs (`.../store/...`) or bare store slugs into **Store URLs**. Each returns a restaurant detail row plus its menu.
3. To cover a market, enter a **City** and a **Search query** like "burgers" or "ramen". Leave the search blank and turn on **Scrape all restaurants** to pull a whole city's restaurants instead.
4. Add a delivery **Address** to anchor availability, set **Max restaurants** (up to 200), and optionally turn on **Include reviews**.
5. Pick a **Sort** order and a **Price range** filter, then **Start**. Export to JSON, CSV, or Excel, or pull results through the API.

### What can you scrape with it? Input examples

The input form is prefilled, so you can press **Start** right away. Copy any of these ready-to-run jobs to match your goal.

#### 1. Search a city for a cuisine

You run a food blog and want every pizza spot in New York, with menus and prices, in one export.

```json
{
  "city": "new-york-city",
  "searchQuery": "pizza",
  "maxResults": 100
}
````

#### 2. Every restaurant in a city

You are building a delivery-market dataset and need Chicago's full restaurant landscape, not just a single search page.

```json
{
  "city": "chicago",
  "listAll": true,
  "maxResults": 200
}
```

#### 3. Top-rated first

You are a franchise scout who only cares about the highest-rated sushi in the market, ranked from the top down.

```json
{
  "city": "chicago",
  "searchQuery": "sushi",
  "sort": "rating",
  "maxResults": 100
}
```

#### 4. Full menus for specific restaurants

You already know the restaurants and want each one's complete menu with per-item prices and dietary flags. Bare slugs or restaurant names work too - just add a **City** so we resolve them to the right location.

```json
{
  "storeUrls": [
    "https://www.ubereats.com/store/pizza-hut-932-8th-ave/-8LRUcceXwC0jh4Qg32Y4Q"
  ]
}
```

#### 5. Reviews for sentiment analysis

You are a product team mining what diners say about ramen spots, up to 50 reviews per restaurant across the top 30 places.

```json
{
  "city": "new-york-city",
  "searchQuery": "ramen",
  "includeReviews": true,
  "maxReviewsPerRestaurant": 50,
  "maxResults": 30
}
```

### Output example

A restaurant detail row with its menu nested under `data`:

```json
{
  "query": "pizza",
  "row_type": "restaurant_detail",
  "name": "Joe's Pizza",
  "slug": "joes-pizza-carmine-st",
  "address": "7 Carmine St, New York, NY 10014",
  "rating": 4.7,
  "review_count": 1820,
  "price_range": "$",
  "categories": ["Pizza", "Italian"],
  "phone": "+12123661182",
  "delivery_time_min": 15,
  "delivery_time_max": 30,
  "is_open": true,
  "menu_item_count": 48,
  "data": {
    "menu": [
      {
        "name": "Classic Pies",
        "items": [
          {
            "name": "Cheese Slice",
            "price": 3.49,
            "dietary": ["Vegetarian"]
          }
        ]
      }
    ]
  }
}
```

A review row:

```json
{
  "query": "joes-pizza-carmine-st",
  "row_type": "review",
  "author": "Marcus D.",
  "rating": 5,
  "text": "Best slice in the city and delivery was fast.",
  "date": "2 weeks ago"
}
```

### Output row types

Every row carries a `row_type` field, so you can split the dataset by shape:

| `row_type` | What it is | Price / 1,000 |
|---|---|---|
| `restaurant_result` | A compact listing row from a city search or whole-city sweep | $1.50 |
| `restaurant_detail` | A full restaurant profile with the complete menu nested under `data.menu` | $5.00 |
| `review` | A single diner review (reviewer, rating, text, date) | $0.40 |

Error rows (a `row_type` plus `error_code` and `error_message`) are pushed when a restaurant cannot be resolved, and they are never charged.

### How much does it cost to scrape Uber Eats?

You pay per result, no monthly fee.

| Result | Price | Per 1,000 |
|---|---|---|
| Restaurant listing | $0.0015 | $1.50 |
| Restaurant detail + menu | $0.005 | $5.00 |
| Review | $0.0004 | $0.40 |

Worked example: the **$5 free Apify credits** new accounts get cover about **3,300 restaurant listings** ($5 / $0.0015), **1,000 restaurants with menus** ($5 / $0.005), or **12,500 reviews** ($5 / $0.0004). Error rows are never charged, so failed lookups do not eat your budget.

### What can you use Uber Eats data for?

- **Menu and price intelligence** - track competitor dish prices and menu items across a market.
- **Market coverage** - map a city's restaurant landscape by cuisine, rating, and price tier.
- **Competitor monitoring** - watch a rival chain's ratings, menu items, and price changes.
- **Food delivery research** - analyze delivery ETAs and restaurant availability by neighborhood.
- **Restaurant lead generation** - build prospect lists by city and cuisine for sales outreach.
- **Review and sentiment analysis** - mine review text and ratings for product feedback.
- **Pricing strategy** - benchmark your menu against local competitors before a launch.
- **Menu digitization** - feed structured menu data into apps, aggregators, or AI training sets.
- **Geographic expansion** - spot underserved cuisines and neighborhoods before you open.

### Is it legal to scrape Uber Eats?

Scraping publicly available information is generally legal, and this actor only collects public restaurant, menu, and review data visible to any visitor without an account. You are responsible for how you use it: follow applicable laws like GDPR and CCPA, respect intellectual property, and consult a lawyer if you are unsure.

### FAQ

**Is scraping Uber Eats legal?**
Scraping publicly available information is generally legal, and this Actor only collects public restaurant, menu, and review data that any visitor can see. You are responsible for how you use the data - follow applicable laws like GDPR and CCPA. See the legal note above for detail.

**How fresh is the data?**
Every field is fetched live from Uber Eats on each run, so prices, ratings, ETAs, and menus reflect what is on the site at run time. Re-run or schedule the Actor to keep a dataset current.

**What happens if a restaurant is not found?**
The Actor pushes an error row (with `error_code` and `error_message`) for that input and keeps going with the rest of the run. Error rows are never charged, so one bad slug does not stop the job or cost you money.

**Can I schedule it?**
Yes. Use Apify Schedules to run the Actor hourly, daily, or weekly, and connect webhooks or integrations (Google Sheets, Slack, S3, and more) to push fresh results downstream automatically.

**Do I need an Uber Eats account?**
No credentials are required. You provide a city and search, or store URLs, and the Actor returns public data.

**Can I get the menu for each restaurant?**
Yes. Each restaurant detail row carries menu section and item counts as columns, and the full menu (60-131 items in our runs, with sections, prices, photos, and dietary labels) is nested under the `data.menu` field.

**Can I run this from my own code or an AI agent?**
Yes. Start runs and read results through the Apify API, the JavaScript and Python SDKs, or MCP for AI agents and assistants. Each output format (JSON, CSV, Excel) is available programmatically.

**How do I scrape a specific restaurant instead of a whole city?**
Paste its Uber Eats store URL, bare slug, or restaurant name into **Store URLs** (add a **City** so slugs and names resolve to the right location). You can mix several restaurants in one run.

**Why are some fields empty?**
Listing rows carry fewer fields than detail rows, and review rows carry review fields. An empty value means the field does not apply to that row type or was not published by the restaurant. Add a precise delivery **Address** to anchor availability to a real location.

### Related actors

More food, travel, and hospitality scrapers from the Data Forge fleet:

- 🏨 **[Booking Hotels Scraper](https://apify.com/jdtpnjtp/booking-hotels-scraper)** - hotel listings, prices, and availability across any destination for travel and hospitality research.
- ⭐ **[Booking Reviews Scraper](https://apify.com/jdtpnjtp/booking-reviews-scraper)** - guest reviews and rating breakdowns to pair with restaurant sentiment analysis.
- 🗺️ **[TripAdvisor Scraper](https://apify.com/jdtpnjtp/tripadvisor)** - restaurant and hotel ratings, reviews, and rankings for travel and dining research.

### Support

[![Telegram](https://img.shields.io/badge/Telegram-Chat-26A5E4?style=for-the-badge\&logo=telegram\&logoColor=white)](https://t.me/j4dtpnj2tp)
[![WhatsApp](https://img.shields.io/badge/WhatsApp-Message-25D366?style=for-the-badge\&logo=whatsapp\&logoColor=white)](https://wa.me/380686031542)
[![Email](https://img.shields.io/badge/Email-jdtpnjtp%40gmail.com-EA4335?style=for-the-badge\&logo=gmail\&logoColor=white)](mailto:jdtpnjtp@gmail.com)

# Actor input Schema

## `storeUrls` (type: `array`):

Uber Eats store URLs (.../store/...), bare store slugs (e.g. 'uncle-pauls-pizza'), or restaurant names. Bare slugs and names are auto-resolved - set City so we match the right location. Each returns full restaurant detail + complete menu.

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

City to search in - adaptive (slug like 'new-york', a city URL, or a human name). Required for search/listing mode; also used to resolve bare store slugs / restaurant names in Store URLs.

## `searchQuery` (type: `string`):

What to search for in the city (e.g. 'pizza', 'sushi'). Combine with City. Leave blank and turn on 'Scrape all restaurants' to pull the whole city.

## `listAll` (type: `boolean`):

Pull every restaurant in the city without a search query (combine with City). Bounded by Max restaurants.

## `address` (type: `string`):

Optional delivery address to anchor the store list to a precise point (e.g. '200 W 57th St, New York, NY'). Recommended for accurate availability.

## `maxResults` (type: `integer`):

Upper bound on restaurants pulled from a city search/listing (1-200). Each is fetched to full detail + menu.

## `includeReviews` (type: `boolean`):

Also pull reviews for each restaurant (adds a review charge per review).

## `maxReviewsPerRestaurant` (type: `integer`):

Cap on reviews per restaurant when Include reviews is on (1-100).

## `sort` (type: `string`):

Sort order for the city search.

## `priceRange` (type: `string`):

Price-level filter for the city search.

## Actor input object example

```json
{
  "storeUrls": [],
  "city": "new-york",
  "searchQuery": "pizza",
  "listAll": false,
  "address": "",
  "maxResults": 20,
  "includeReviews": false,
  "maxReviewsPerRestaurant": 20,
  "sort": "",
  "priceRange": ""
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset; row\_type discriminates restaurant\_result / restaurant\_detail / review. The full menu (sections + items) is under data.menu on detail rows.

## `summary` (type: `string`):

OUTPUT key: restaurant\_results, restaurant\_details, reviews, errors, total\_rows, estimated\_cost\_usd, limit\_reached, actor\_version.

# 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 = {
    "storeUrls": [],
    "city": "new-york",
    "searchQuery": "pizza",
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("jdtpnjtp/uber-eats-restaurant-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "storeUrls": [],
    "city": "new-york",
    "searchQuery": "pizza",
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("jdtpnjtp/uber-eats-restaurant-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "storeUrls": [],
  "city": "new-york",
  "searchQuery": "pizza",
  "maxResults": 20
}' |
apify call jdtpnjtp/uber-eats-restaurant-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Uber Eats Restaurant Scraper",
        "description": "Scrape Uber Eats restaurants and menus by city, search, or store URL. Extract restaurant name, rating, cuisine, address, delivery fee, menu items, prices, and reviews as clean JSON. Pay per result.",
        "version": "1.0",
        "x-build-id": "3KdDdnudu8aMLIkBr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jdtpnjtp~uber-eats-restaurant-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jdtpnjtp-uber-eats-restaurant-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/jdtpnjtp~uber-eats-restaurant-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jdtpnjtp-uber-eats-restaurant-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/jdtpnjtp~uber-eats-restaurant-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jdtpnjtp-uber-eats-restaurant-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "storeUrls": {
                        "title": "Store URLs or slugs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Uber Eats store URLs (.../store/...), bare store slugs (e.g. 'uncle-pauls-pizza'), or restaurant names. Bare slugs and names are auto-resolved - set City so we match the right location. Each returns full restaurant detail + complete menu.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City to search in - adaptive (slug like 'new-york', a city URL, or a human name). Required for search/listing mode; also used to resolve bare store slugs / restaurant names in Store URLs.",
                        "default": ""
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "What to search for in the city (e.g. 'pizza', 'sushi'). Combine with City. Leave blank and turn on 'Scrape all restaurants' to pull the whole city.",
                        "default": ""
                    },
                    "listAll": {
                        "title": "Scrape all restaurants in the city",
                        "type": "boolean",
                        "description": "Pull every restaurant in the city without a search query (combine with City). Bounded by Max restaurants.",
                        "default": false
                    },
                    "address": {
                        "title": "Delivery address",
                        "type": "string",
                        "description": "Optional delivery address to anchor the store list to a precise point (e.g. '200 W 57th St, New York, NY'). Recommended for accurate availability.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max restaurants",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Upper bound on restaurants pulled from a city search/listing (1-200). Each is fetched to full detail + menu.",
                        "default": 20
                    },
                    "includeReviews": {
                        "title": "Include reviews",
                        "type": "boolean",
                        "description": "Also pull reviews for each restaurant (adds a review charge per review).",
                        "default": false
                    },
                    "maxReviewsPerRestaurant": {
                        "title": "Max reviews per restaurant",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Cap on reviews per restaurant when Include reviews is on (1-100).",
                        "default": 20
                    },
                    "sort": {
                        "title": "Search sort",
                        "enum": [
                            "",
                            "rating",
                            "recommended",
                            "earliest_arrival"
                        ],
                        "type": "string",
                        "description": "Sort order for the city search.",
                        "default": ""
                    },
                    "priceRange": {
                        "title": "Price range",
                        "enum": [
                            "",
                            "$",
                            "$$",
                            "$$$",
                            "$$$$"
                        ],
                        "type": "string",
                        "description": "Price-level filter for the city search.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
