# Booking Reviews Scraper (`simpleapi/booking-reviews-scraper`) Actor

This scraper retrieves Booking hotel reviews with accuracy, including comments, scores, stay dates, and reviewer info. Designed for scalable data collection to support research teams, AI training sets, and competitive analysis projects.

- **URL**: https://apify.com/simpleapi/booking-reviews-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** Automation, Lead generation, Travel
- **Stats:** 6 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

### 🔍 What does a Booking Reviews Scraper do?

A Booking Reviews Scraper is a powerful automation tool designed to collect customer reviews, ratings, hotel details, and sentiment insights directly from Booking.com. It simplifies the entire data extraction process — no manual copy-paste, no repeated page checks. Just enter your URLs and instantly retrieve structured data ready for analysis. ✨

For SEO professionals, researchers, marketers, and hospitality businesses, this scraper is a goldmine. It helps analyze audience sentiment, benchmark competitor hotels, and evaluate trust signals like Booking review example and is Booking reliable queries.

It also integrates seamlessly with Apify and works similarly to tools like voyager booking reviews scraper, apify reviews, and booking com scraper GitHub alternatives — making it perfect for large-scale data collection.

* * *

### 📦 What Booking Reviews Scraper Can Extract

Below is a detailed table of the data types extractable using this scraper (including use cases like scrape TripAdvisor reviews, scrape hotel prices, and tripadvisor scraping comparisons).

#### 📊 Extractable Data Table 

| Data Type | Description | Example Use Case |
| --- | --- | --- |
| Reviewer Name | The name or alias of the reviewer | Identify demographic patterns |
| Review Text | Full written review | Sentiment analysis & keyword extraction |
| Review Score | Rating left by the user | Compare hotels & build scoring models |
| Review Date | The date the review was posted | Trend analysis over time |
| Hotel Name | Property name from Booking.com | Competitive research |
| Room Type | Room variant mentioned | Understand consumer preferences |
| Location Info | City, region, or country | Mapping & geospatial research |
| Review URL / booking.com review link | Direct link to the review | Verification, auditing |
| Price Snippets | Basic price info (when available) | Compare platforms, scrape hotel prices |
| Metadata | Useful attributes for NLP | Build datasets for ML models |

* * *

#### ⚙️ Key Features of the Booking Reviews Scraper 

#### 🌟 Features You’ll Love

*   Advanced Review Extraction 📥 — Capture thousands of reviews including text, scores, room insights, and timestamps.  
      
    
*   Multi-Platform Support 🔗 — Works alongside other tools such as apify tripadvisor scraper, voyager booking reviews scraper, and booking.com scraper variations.  
      
    
*   GraphQL-ready compatibility ⚡ — Designed to work smoothly with modern Booking.com structures like booking com graphql patterns without revealing technical logic.  
      
    
*   Bulk Input Handling 🧩 — Upload multiple hotel URLs at once for large-scale extraction. Perfect for enterprise researchers.  
      
    
*   Export to JSON, CSV, Excel 📄 — Easy download for analysis, dashboards, market research, or BI pipelines.  
      
    
*   SEO & Market Intelligence Boost 🚀 — Great for content teams analyzing bestweb-traffic.com review, competitor trust, and brand perception.  
      
    
*   Lightning-speed Processing ⚡ — Optimized for efficiency to help scrape Booking.com swiftly and safely.  
      
    
*   NLP-Ready Output 🤖 — Structured fields perfect for embeddings, clustering, or sentiment modeling.  
      
    

* * *

### 🧭 How to Use the Booking Reviews Scraper

Here’s the simplest step-by-step guide to start extracting Booking.com review data — even if you’re a beginner. 🔽

#### 🛠️ Step-by-Step Guide

1.  Log in to Apify — Create a free account or sign in.  
      
    
2.  Select the Actor — Search for “Booking Reviews Scraper” or similar actors like YouTube Transcript Scraper in the Apify Store (template instructions).  
      
    
3.  Enter Input Data — Add one or multiple Booking.com hotel URLs into the startUrls field.  
      
    
4.  Choose Options — Select whether you want detailed metadata, timestamps, or simplified outputs.  
      
    
5.  Run the Actor — Hit Start, and the scraper automatically extracts reviews.  
      
    
6.  Download Results — Export in JSON, CSV, Excel, or API formats for instant use.  
      
    

This workflow mirrors other popular tools like scrape booking.com, tripadvisor scraping, and booking scraper engines — but with greater stability and more detailed review structures.

* * *

### 🎯 Use Cases for Booking Reviews Scraper

This tool is incredibly versatile and supports a wide range of industries. Here are the most impactful applications:

*   📈 Market Research — Benchmark hotels, compare ratings, and identify trends across global destinations.  
      
    
*   🧳 Hospitality Business Optimization — Identify service gaps from customer complaints and improve the guest experience.  
      
    
*   📊 Competitor Analysis — Compare your property’s reviews with rival hotels using booking review example datasets.  
      
    
*   🤖 AI & NLP Research — Extract structured data for training classification models, sentiment engines, and embeddings.  
      
    
*   💼 Agency & SEO Workflows — Create SEO content using real review insights, track sentiment shifts, and monitor competitor authority.  
      
    
*   🛒 Price Monitoring — Combine with tools that scrape hotel prices to track price changes across platforms.  
      
    
*   🗺️ Travel Platforms — Build travel recommendation engines, summaries, and ranking algorithms.  
      
    

* * *

### 💡 Why Choose Us?

We deliver a high-performance Booking Reviews Scraper designed for speed, accuracy, and enterprise reliability. 🚀

Here’s why thousands choose this solution:

*   Precision Extraction — Our scraper collects detailed information without missing critical data points.  
      
    
*   Scalable Infrastructure — Perfect for teams running thousands of hotel URLs daily.  
      
    
*   Trusted Across Industries — Used by marketers, analysts, AI developers, and booking research experts.  
      
    
*   Best-in-Class Support — Includes guidance for integrations and workflows.  
      
    
*   NLP-Optimized Output — Structured for machine learning, enabling advanced sentiment and topic modeling.  
      
    
*   Compatible Ecosystem — Works smoothly with tools found under booking com scraper GitHub, apify reviews, and similar platforms.  
      
    

* * *

### 📈 How Many Results Can You Scrape with Booking Reviews Scraper? 

Scalability is one of the strongest advantages of this scraping solution. Whether you're extracting 100 reviews or 300,000+ reviews, the tool is built to handle massive datasets smoothly.

#### ⚡ High-Performance, High-Volume Extraction

*   Supports batch URLs, allowing extraction of multiple hotels simultaneously.  
      
    
*   Handles pagination automatically, ensuring you capture all reviews available — even older ones.  
      
    
*   Ideal for large hotels with thousands of customer comments, photos, and metadata.  
      
    

#### 🚀 Enterprise-Ready Scalability

This scraper is frequently used by:

*   Travel platforms aggregating review datasets  
      
    
*   SEO firms monitoring customer sentiment  
      
    
*   Data scientists building trend prediction models  
      
    
*   Hospitality brands conducting competitive audits  
      
    

#### 🌍 Global Coverage

Whether your review target is in Europe, Asia, or North America, this scraper retrieves multilingual reviews reliably — helpful for NLP applications, sentiment engines, or translation-based analytics.

If you're dealing with tools like voyager booking reviews scraper, booking scraper, or apify tripadvisor scraper, you’ll find this solution offers even greater flexibility and structure for large-scale research.

* * *

### ⚖️ Is It Legal to Scrape Booking Reviews? 

Web scraping legality depends on how the data is collected and how it’s used.

#### ✔ Generally Allowed

*   Publicly available data such as reviews can typically be scraped if no login is required.  
      
    
*   Ethical data usage is key — use reviews for research, analysis, or internal business insights.  
      
    

#### ⚠ Always Follow Best Practices

*   Review Booking.com’s Terms of Service.  
      
    
*   Avoid scraping personal information such as phone numbers unless clearly public (booking reviews scraper phone number queries apply here).  
      
    
*   Use data responsibly and avoid re-publishing content without permission.  
      
    

Always ensure compliance with local laws, platform guidelines, and fair-use principles.

* * *

### 🧩 Input Parameters

#### JSON Example
```json
{
  "startUrls": [
    "https://www.booking.com/hotel/cz/jeromehouse.en-gb.html",
    "Hilton New York",
    "https://www.booking.com/hotel/us/hilton-garden-inn-new-york-west-35th-street.html"
  ],
  "sortOrder": "Most relevant",
  "maxComments": 100,
  "reviewScores": ["ALL"],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### 📤 Output Format

#### JSON Example

```json
[
  {
    "likedText": "Quiet location, but close to everything! Friendly staff, plentiful breakfast",
    "dislikedText": "An indoor lounge area, where you can sit indoors out of the room",
    "reviewTitle": "Great stay in Heart of Prague",
    "travelerType": "Couple",
    "userLocation": "United States",
    "userName": "Jessie",
    "userAvatar": "https://xx.bstatic.com/static/img/review/avatars/ava-j.png",
    "rating": 10.0,
    "propertyResponse": null,
    "checkInDate": "2025-11-27",
    "checkOutDate": "2025-11-28",
    "reviewDate": "2025-11-30T01:09:24.000Z",
    "images": [
      "https://cf.bstatic.com/xdata/images/hotel/max1280x900/123456.jpg"
    ],
    "id": "ee9dd8edb416000a",
    "roomInfo": "Standard Double or Twin Room",
    "numberOfNights": 1,
    "reviewLanguage": "en",
    "stayRoomId": 7704007,
    "helpfulVotes": 0,
    "totalCategoryReviews": 5723,
    "hotelRatingScores": [
      {
        "name": "Staff",
        "codeName": "hotel_staff",
        "score": 9.64
      },
      {
        "name": "Facilities",
        "codeName": "hotel_services",
        "score": 8.80
      },
      {
        "name": "Cleanliness",
        "codeName": "hotel_clean",
        "score": 9.23
      }
    ],
    "hotelId": 77040,
    "reviewsScoreFilter": "ALL",
    "reviewPage": 1,
    "startUrl": "https://www.booking.com/hotel/cz/jeromehouse.en-gb.html"
  }
]
```

### ❓ FAQ

#### 1. Is a Booking Reviews Scraper safe to use?

Yes — when used ethically and within platform guidelines.

#### 2. Can I scrape multiple hotels at once?

Absolutely! Just add multiple URLs to the startUrls list.

#### 3. Does this support scrape tripadvisor reviews?

Indirectly — but you can use related tools like apify tripadvisor scraper.

#### 4. Can I export the reviews to Excel?

Yes, CSV, JSON, XLSX, and API formats are supported.

#### 5. Is it faster than tools on booking com scraper GitHub?

Yes — it’s built for stability, scale, and enterprise use.

#### 6. Can I scrape hotel prices too?

Basic price snippets may be available; for full pricing use a scrape hotel prices tool.

#### 7. Does it support NLP analysis?

Yes — perfect for clustering, sentiment scoring, embeddings, and topic modeling.

### 🏁 Conclusion

The Booking Reviews Scraper is an essential tool for extracting reliable hotel insights, analyzing customer sentiment, and powering data-driven decisions. Whether you're comparing competitors, running NLP analysis, or monitoring hospitality trends, this scraper offers accuracy, scalability, and actionable data—far beyond traditional booking.com scraper solutions. Perfect for businesses, researchers, and travel platforms.

# Actor input Schema

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

List one or more Booking.com hotel page URLs (e.g., https://www.booking.com/hotel/cz/jeromehouse.en-gb.html), hotel names, or keywords. URLs are used directly; names/keywords will be searched on Booking.com.

## `sortOrder` (type: `string`):

Sort reviews by one of Booking.com's options.

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

Maximum number of items to scrape per hotel.

## `reviewScores` (type: `array`):

Filter by score category (first value used). Maps: ALL → ALL, wonderful → REVIEW\_ADJ\_SUPERB (9+), good → REVIEW\_ADJ\_GOOD (7-9), fair → REVIEW\_ADJ\_AVERAGE\_PASSABLE (5-7), poor → REVIEW\_ADJ\_POOR (3-5), very\_poor → REVIEW\_ADJ\_VERY\_POOR (1-3).

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

Optional proxy settings. By default, no proxy is used. Actor automatically falls back to datacenter → residential if blocked. Leave empty to use no proxy.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.booking.com/hotel/cz/jeromehouse.en-gb.html",
    "https://www.booking.com/hotel/us/hilton-garden-inn-new-york-west-35th-street.html"
  ],
  "sortOrder": "Most relevant",
  "maxItems": 50,
  "reviewScores": [
    "ALL"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "https://www.booking.com/hotel/cz/jeromehouse.en-gb.html",
        "https://www.booking.com/hotel/us/hilton-garden-inn-new-york-west-35th-street.html"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/booking-reviews-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": [
        "https://www.booking.com/hotel/cz/jeromehouse.en-gb.html",
        "https://www.booking.com/hotel/us/hilton-garden-inn-new-york-west-35th-street.html",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/booking-reviews-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": [
    "https://www.booking.com/hotel/cz/jeromehouse.en-gb.html",
    "https://www.booking.com/hotel/us/hilton-garden-inn-new-york-west-35th-street.html"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call simpleapi/booking-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Booking Reviews Scraper",
        "description": "This scraper retrieves Booking hotel reviews with accuracy, including comments, scores, stay dates, and reviewer info. Designed for scalable data collection to support research teams, AI training sets, and competitive analysis projects.",
        "version": "0.1",
        "x-build-id": "99yagSY9gxYV8xytI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/simpleapi~booking-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-simpleapi-booking-reviews-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/simpleapi~booking-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-simpleapi-booking-reviews-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/simpleapi~booking-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-simpleapi-booking-reviews-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",
                    "sortOrder",
                    "maxItems"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Hotel URLs, Hotel Names, or Keywords",
                        "type": "array",
                        "description": "List one or more Booking.com hotel page URLs (e.g., https://www.booking.com/hotel/cz/jeromehouse.en-gb.html), hotel names, or keywords. URLs are used directly; names/keywords will be searched on Booking.com.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortOrder": {
                        "title": "Sort Order",
                        "enum": [
                            "Most relevant",
                            "Newest first",
                            "Oldest first",
                            "Highest scores",
                            "Lowest scores"
                        ],
                        "type": "string",
                        "description": "Sort reviews by one of Booking.com's options.",
                        "default": "Most relevant"
                    },
                    "maxItems": {
                        "title": "Max Items To Scrape",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of items to scrape per hotel.",
                        "default": 50
                    },
                    "reviewScores": {
                        "title": "Review Scores Filter",
                        "type": "array",
                        "description": "Filter by score category (first value used). Maps: ALL → ALL, wonderful → REVIEW_ADJ_SUPERB (9+), good → REVIEW_ADJ_GOOD (7-9), fair → REVIEW_ADJ_AVERAGE_PASSABLE (5-7), poor → REVIEW_ADJ_POOR (3-5), very_poor → REVIEW_ADJ_VERY_POOR (1-3).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ALL",
                                "wonderful",
                                "good",
                                "fair",
                                "poor",
                                "very_poor"
                            ]
                        },
                        "default": [
                            "ALL"
                        ]
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration (Optional)",
                        "type": "object",
                        "description": "Optional proxy settings. By default, no proxy is used. Actor automatically falls back to datacenter → residential if blocked. Leave empty to use no 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```