# OpenTable Restaurants, Ratings & Reviews Scraper (`muhammadafzal/opentable-scraper`) Actor

Scrape OpenTable restaurants in any city. Export profiles, ratings, reviews, cuisines, prices, hours, and coordinates as structured JSON. MCP-ready.

- **URL**: https://apify.com/muhammadafzal/opentable-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** Travel, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 restaurant scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## OpenTable Restaurants, Ratings & Reviews Scraper

Scrape OpenTable restaurants in any city. Export profiles, ratings, reviews, menus, cuisine, price, hours, and coordinates as structured JSON, CSV, or Excel. MCP-ready for AI agents.

### Features

- **Search by city, cuisine, neighborhood, or restaurant name** — paginate through all OpenTable search results
- **Scrape by direct URL** — paste any OpenTable restaurant profile URL
- **Full restaurant profiles** — name, description, overall rating, review counts, cuisines, price tier, address, coordinates, neighborhood, metro, phone, website, hours, dining style, dress code, parking, executive chef, features (bar, counter, outdoor, high-top, max party size), private dining, takeout, delivery, payment options, gallery photos
- **Optional reviews extraction** — collect individual reviews with full text, diner profiles (name, initials, location, VIP status, review count), dined/submitted dates, and helpfulness votes
- **Browser-based anti-bot bypass** — uses Playwright with Chromium + response interception to capture OpenTable's API responses with correct TLS fingerprints, defeating Akamai protection
- **MCP-ready** — optimized for Claude, ChatGPT, Cursor, and other AI agents with semantic field names and structured output

### Use Cases

- Competitive analysis and benchmarking of nearby restaurants (ratings, amenities, price band)
- Market-entry research and city-level restaurant coverage studies
- Restaurant scoring, ranking, and neighborhood food-density analysis
- Review monitoring and sentiment analysis
- Sourcing acquisition or M&A targets using reservation counts and review velocity
- Enriching travel apps, directories, and restaurant profile databases with geocoordinates
- Building city guides, affiliate booking pages, and editorial "best of" lists
- Generating prospect lists and CRM enrichment for sales outreach
- Training recommendation models and AI prototypes on real restaurant attributes

### Input

The actor supports two input modes (can be combined):

#### Search Terms

Provide city names, neighborhoods, cuisines, or restaurant names:

```json
{
    "searchTerms": ["New York", "Italian Chicago", "sushi San Francisco"],
    "maxResults": 500,
    "includeReviews": false
}
````

#### Direct URLs

Provide specific OpenTable restaurant URLs:

```json
{
    "startUrls": [
        { "url": "https://www.opentable.com/r/le-bernardin-new-york" },
        { "url": "https://www.opentable.com/restaurant/profile/100" }
    ],
    "includeReviews": true,
    "maxReviewsPerRestaurant": 50
}
```

#### All Input Fields

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchTerms` | array | `["New York"]` | City, neighborhood, cuisine, or restaurant names to search |
| `startUrls` | array | `[]` | Direct OpenTable restaurant URLs |
| `maxResults` | integer | `100` | Max restaurant records to return |
| `priceBands` | array | `[]` | Filter by price tier (1-4) |
| `sortBy` | string | `web_conversion` | Sort order: `web_conversion` (featured) or `distance` |
| `includeReviews` | boolean | `false` | Also scrape individual reviews |
| `maxReviewsPerRestaurant` | integer | `50` | Max reviews per restaurant |
| `proxyConfiguration` | object | Apify Proxy | Proxy routing (residential recommended) |

### Output

Each record contains:

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Restaurant name |
| `url` | string | OpenTable profile URL |
| `restaurantId` | number | OpenTable internal ID |
| `description` | string | Restaurant description |
| `rating` | number | Overall rating (1-5) |
| `reviewCount` | number | Recent review count |
| `totalReviewCount` | number | Total reviews |
| `primaryCuisine` | string | Primary cuisine |
| `cuisines` | string\[] | All cuisine tags |
| `priceTier` | number | Price band (1-4) |
| `priceRange` | string | Price label |
| `address` | object | Full postal address |
| `latitude` | number | Geocode |
| `longitude` | number | Geocode |
| `neighborhood` | string | Neighborhood |
| `metro` | string | Metro area |
| `phoneNumber` | string | Contact phone |
| `website` | string | Restaurant website |
| `hoursOfOperation` | string | Hours text |
| `diningStyle` | string | Dining style |
| `dressCode` | string | Dress code |
| `parkingInfo` | string | Parking details |
| `executiveChef` | string | Chef name |
| `imageUrl` | string | Cover photo URL |
| `features` | object | Bar, counter, outdoor, highTop, maxPartySize |
| `hasPrivateDining` | boolean | Private dining available |
| `hasTakeout` | boolean | Takeout available |
| `paymentOptions` | string\[] | Accepted payments |
| `photoUrls` | string\[] | Gallery photos |
| `reviews` | array | Individual reviews (if enabled) |
| `scrapedAt` | string | ISO timestamp |
| `sourceUrl` | string | Source URL |

#### Review Object (when `includeReviews` is true)

| Field | Type | Description |
|-------|------|-------------|
| `reviewId` | string | Unique review ID |
| `text` | string | Full review text |
| `dinedDate` | string | Dine-in date (ISO) |
| `submittedDate` | string | Submission date (ISO) |
| `ratingOverall` | number | Overall rating |
| `reviewerName` | string | Diner nickname |
| `reviewerInitials` | string | Diner initials |
| `reviewerLocation` | string | Diner city |
| `reviewerIsVip` | boolean | VIP status |
| `reviewerApprovedReviewCount` | number | Diner's total reviews |
| `reviewHelpfulUp` | number | Helpful up-votes |
| `reviewHelpfulDown` | number | Helpful down-votes |

### Pricing

This actor uses **Pay-Per-Event** pricing:

| Event | Price | Description |
|-------|-------|-------------|
| Restaurant scraped | **$0.005** | Per restaurant record returned |
| Review scraped | **$0.001** | Per review returned (only when `includeReviews` is enabled) |
| Actor start | **$0.00005** | Per run start (memory-based) |

**Example costs:**

- 100 restaurants, no reviews: ~$0.50
- 100 restaurants with 50 reviews each (5,000 reviews): ~$5.50 ($0.50 + $5.00)
- 1,000 restaurants, no reviews: ~$5.00

### How It Works

The actor uses a **3-layer extraction strategy** to maximize reliability against OpenTable's Akamai protection:

1. **Response interception** (primary) — Playwright's `page.on('response')` captures OpenTable's own API JSON responses with correct TLS fingerprints and auth headers
2. **Embedded JSON extraction** (fallback) — parses `window.__NEXT_DATA__` and `<script type="application/json">` SSR hydration data
3. **DOM parsing** (last resort) — multi-selector fallback extraction from rendered HTML

### Technical Details

- **Crawler**: PlaywrightCrawler with Chromium launcher
- **Anti-bot**: Browser-based with response interception, randomized viewports, random delays, session pooling
- **Proxy**: Apify Proxy (datacenter default, residential recommended for blocked regions)
- **Language**: TypeScript
- **Output**: Structured JSON dataset (exportable as CSV, Excel, JSON, XML via Apify Console)

### Export Scraped Data

Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools via the Apify platform. Results can be downloaded as JSON, CSV, Excel, or XML from the Apify Console.

### API Usage

```bash
## Run via API
curl -X POST "https://api.apify.com/v2/acts/USERNAME~opentable-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["New York"], "maxResults": 100}'
```

```javascript
// Run via JavaScript SDK
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('USERNAME/opentable-scraper').call({
    searchTerms: ['New York'],
    maxResults: 100
});
const dataset = await client.dataset(run.defaultDatasetId);
const items = await dataset.listItems();
```

### Limitations

- OpenTable uses Akamai protection — residential proxies may be required for some regions
- Free users are limited to 10 results per run
- Review extraction adds significant time per restaurant
- Some fields may be null if OpenTable doesn't provide them for a given restaurant

### Support

If you encounter issues, please report them on the [Issues tab](https://apify.com/USERNAME/opentable-scraper/issues) in the Apify Console.

# Actor input Schema

## `searchTerms` (type: `array`):

Use this field when the user provides a city, neighborhood, cuisine, or restaurant name to search on OpenTable. Each entry is paginated separately. Examples: 'New York', 'Italian Chicago', 'sushi San Francisco'. Use startUrls instead when the user provides direct OpenTable restaurant URLs.

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

Use this field when the user provides specific OpenTable restaurant URLs to scrape directly (e.g. https://www.opentable.com/r/le-bernardin-new-york or https://www.opentable.com/restaurant/profile/100). Do NOT use this when the user describes a city or cuisine — use searchTerms for that.

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

Maximum number of restaurant records to return. The scraper stops early when this limit is reached. Default 100. Free users are limited to 10. Paid users can set up to 1,000,000.

## `priceBands` (type: `array`):

Restrict results to specific price tiers. Leave empty for all price bands. $ = Under $30, $$ = $31-50, $$$ = $50-75, $$$$ = $75+. Map to OpenTable price band IDs 1-4.

## `sortBy` (type: `string`):

How OpenTable orders search results. 'web\_conversion' = featured/popular first (default). 'distance' = nearest first.

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

If enabled, also scrape individual reviews (review text, multi-axis ratings, diner profile, dined/submitted dates) for each restaurant. Slows the run. Charged per review at $0.001/review.

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

Maximum number of reviews to collect per restaurant when includeReviews is enabled. Default 50. Set higher for full review history.

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

Connection routing for the run. The default (Apify Proxy) works best for reaching OpenTable reliably. OpenTable uses Akamai protection — residential proxies provide the highest success rate. Only change if your environment requires a custom proxy.

## Actor input object example

```json
{
  "searchTerms": [
    "New York"
  ],
  "startUrls": [],
  "maxResults": 100,
  "priceBands": [],
  "sortBy": "web_conversion",
  "includeReviews": false,
  "maxReviewsPerRestaurant": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All restaurant records extracted from OpenTable. Click to view the full dataset as JSON.

# 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 = {
    "searchTerms": [
        "New York"
    ],
    "startUrls": [],
    "maxResults": 100,
    "includeReviews": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/opentable-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 = {
    "searchTerms": ["New York"],
    "startUrls": [],
    "maxResults": 100,
    "includeReviews": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/opentable-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 '{
  "searchTerms": [
    "New York"
  ],
  "startUrls": [],
  "maxResults": 100,
  "includeReviews": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call muhammadafzal/opentable-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenTable Restaurants, Ratings & Reviews Scraper",
        "description": "Scrape OpenTable restaurants in any city. Export profiles, ratings, reviews, cuisines, prices, hours, and coordinates as structured JSON. MCP-ready.",
        "version": "1.0",
        "x-build-id": "CPoIycuunPT5WekB5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/muhammadafzal~opentable-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-muhammadafzal-opentable-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/muhammadafzal~opentable-scraper/runs": {
            "post": {
                "operationId": "runs-sync-muhammadafzal-opentable-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/muhammadafzal~opentable-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-muhammadafzal-opentable-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": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Use this field when the user provides a city, neighborhood, cuisine, or restaurant name to search on OpenTable. Each entry is paginated separately. Examples: 'New York', 'Italian Chicago', 'sushi San Francisco'. Use startUrls instead when the user provides direct OpenTable restaurant URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Restaurant URLs",
                        "type": "array",
                        "description": "Use this field when the user provides specific OpenTable restaurant URLs to scrape directly (e.g. https://www.opentable.com/r/le-bernardin-new-york or https://www.opentable.com/restaurant/profile/100). Do NOT use this when the user describes a city or cuisine — use searchTerms for that.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "An OpenTable restaurant URL like https://www.opentable.com/r/le-bernardin-new-york."
                                }
                            },
                            "required": [
                                "url"
                            ]
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Maximum number of restaurant records to return. The scraper stops early when this limit is reached. Default 100. Free users are limited to 10. Paid users can set up to 1,000,000.",
                        "default": 100
                    },
                    "priceBands": {
                        "title": "Price Bands",
                        "type": "array",
                        "description": "Restrict results to specific price tiers. Leave empty for all price bands. $ = Under $30, $$ = $31-50, $$$ = $50-75, $$$$ = $75+. Map to OpenTable price band IDs 1-4.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4"
                            ],
                            "enumTitles": [
                                "$ (Under $30)",
                                "$$ ($31 to $50)",
                                "$$$ ($50 to $75)",
                                "$$$$ ($75 and over)"
                            ]
                        },
                        "default": []
                    },
                    "sortBy": {
                        "title": "Sort Order",
                        "enum": [
                            "web_conversion",
                            "distance"
                        ],
                        "type": "string",
                        "description": "How OpenTable orders search results. 'web_conversion' = featured/popular first (default). 'distance' = nearest first.",
                        "default": "web_conversion"
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "If enabled, also scrape individual reviews (review text, multi-axis ratings, diner profile, dined/submitted dates) for each restaurant. Slows the run. Charged per review at $0.001/review.",
                        "default": false
                    },
                    "maxReviewsPerRestaurant": {
                        "title": "Max Reviews Per Restaurant",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect per restaurant when includeReviews is enabled. Default 50. Set higher for full review history.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Connection routing for the run. The default (Apify Proxy) works best for reaching OpenTable reliably. OpenTable uses Akamai protection — residential proxies provide the highest success rate. Only change if your environment requires a custom proxy."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```