# Booking.com Hotel Scraper (`automly/booking-scraper`) Actor

Extract hotel names, nightly prices, guest ratings, room types, taxes and fees, and photo URLs from Booking.com search results and hotel pages. Search by destination and dates, monitor rates on a schedule, and export to JSON, CSV, or Excel. No Booking.com account needed.

- **URL**: https://apify.com/automly/booking-scraper.md
- **Developed by:** [Automly](https://apify.com/automly) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 scraped place results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Booking.com Hotel Scraper

### 🏨 What does Booking.com Hotel Scraper do?

**Booking.com Hotel Scraper** extracts **hotel names, nightly prices, guest ratings, room types, taxes and fees, and photo URLs** from **Booking.com search results and individual hotel pages**. Give it a destination like "Paris" plus your check-in and check-out dates, and it returns the hotels Booking.com shows for that search, priced for those exact dates, guests, and currency.

Use it to build **hotel price monitoring** pipelines, run **travel market research**, feed **rate comparison** dashboards, or collect **hotel inventory data** for a city without copying listings by hand. It works on public pages only: no Booking.com account, no login, no personal data.

### 🧳 What data can I scrape from Booking.com?

<table>
<tr>
<td>🏨 Hotel names and direct hotel URLs</td>
<td>💵 Nightly prices for your exact dates</td>
</tr>
<tr>
<td>⭐️ Guest rating scores</td>
<td>🧾 Taxes and fees as a separate line</td>
</tr>
<tr>
<td>🛏 Room names and unit descriptions</td>
<td>💱 Prices in the currency you choose</td>
</tr>
<tr>
<td>📅 Check-in / check-out dates used for pricing</td>
<td>🌆 Hotel photo URLs</td>
</tr>
<tr>
<td>🔢 Result rank within the search</td>
<td>📍 Address, city, and coordinates when the page provides them</td>
</tr>
</table>

### 🎯 Use cases

- **Hotel rate monitoring**: track how competitor prices move across dates and seasons
- **Travel market research**: compare average nightly rates between cities or districts
- **Price comparison products**: feed live hotel prices into your own app or dashboard
- **Revenue management**: see where your property ranks in search results and how it is priced against neighbors
- **Tourism research**: build datasets of hotel supply, ratings, and pricing for a region

### ⬇️ How to use

1. Open the actor in Apify Console and click **Try for free**.
2. Type a destination into **Location query** (for example `Paris`). Alternatively, paste one or more full Booking.com search URLs into **Booking.com search URLs**, or direct hotel page URLs into **Booking.com hotel URLs**.
3. Set **Check-in date** and **Check-out date** in `YYYY-MM-DD` format, plus the number of **Adults** and **Rooms**.
4. Optionally set **Currency** (for example `USD`) and **Language** (for example `en-us`).
5. Keep **Use Apify Proxy** enabled and add `RESIDENTIAL` to **Proxy groups**.
6. Click **Start**. When the run finishes, open the **Output** tab for a clean hotel table, or download everything from the **Dataset** tab as JSON, CSV, Excel, or XML.

#### 💡 Tips for scraping hotels on Booking.com

1️⃣ **Always provide check-in and check-out dates.** Booking.com only shows complete room and pricing info when dates are set — without them you get listings but thinner pricing data. Prices returned match your exact dates, guest count, and currency.

2️⃣ **Use `locationQuery` as your primary input.** It builds a clean search URL that parses reliably. Pasted search URLs work too, but Booking.com serves some URL variants with a layout that carries no listing data.

3️⃣ **Split big cities into districts for more coverage.** One search returns the first result page (~25 hotels). "Paris Le Marais", "Paris Montmartre", and "Paris Latin Quarter" as separate runs cover far more of the city than one generic "Paris" search.

4️⃣ **Keep residential proxy on.** Booking.com fronts its pages with an AWS WAF JavaScript challenge that blocks most datacenter IPs. The actor runs a real browser to solve it, and residential IPs pass far more reliably.

#### Example input

```json
{
    "locationQuery": "Paris",
    "checkInDate": "2026-08-20",
    "checkOutDate": "2026-08-22",
    "adults": 2,
    "rooms": 1,
    "maxResults": 25,
    "currency": "USD",
    "language": "en-us",
    "useApifyProxy": true,
    "proxyGroups": ["RESIDENTIAL"]
}
````

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchUrls` | array | `[]` | Full Booking.com search result URLs to scrape. Use public URLs only. |
| `hotelUrls` | array | `[]` | Direct public Booking.com hotel page URLs to scrape. |
| `locationQuery` | string | – | Destination name used to build a Booking.com search URL when no search URL is supplied. |
| `checkInDate` | string | – | Check-in date in `YYYY-MM-DD` format. |
| `checkOutDate` | string | – | Check-out date in `YYYY-MM-DD` format. |
| `adults` | integer | `2` | Number of adult guests (1–30). |
| `rooms` | integer | `1` | Number of rooms (1–30). |
| `maxResults` | integer | `50` | Maximum number of hotel records to emit (1–500). |
| `currency` | string | – | Currency code to request, for example `USD` or `EUR`. |
| `language` | string | – | Language/locale to request, for example `en-us`. |
| `requestTimeoutSecs` | integer | `30` | Timeout for each page request in seconds (5–120). |
| `useApifyProxy` | boolean | `true` | Route requests through Apify Proxy. Keep this on. |
| `proxyGroups` | array | `[]` | Proxy groups to use, for example `["RESIDENTIAL"]` (recommended). |

At least one of `searchUrls`, `hotelUrls`, or `locationQuery` is required.

### ⬆️ Output example

Results appear in the **Output** tab as a sortable hotel table, and in the **Dataset** tab for export. Each hotel looks like this (taken from a real run for Paris, 20–22 August 2026):

```json
{
    "searchUrl": "https://www.booking.com/searchresults.html?ss=Paris&group_adults=2&no_rooms=1&checkin=2026-08-20&checkout=2026-08-22&selected_currency=USD&lang=en-us",
    "hotelUrl": "https://www.booking.com/hotel/fr/appart-39-odalys-paris-xvii.html?checkin=2026-08-20&checkout=2026-08-22&group_adults=2&no_rooms=1",
    "hotelName": "Appart'hôtel Odalys City - Paris XVII",
    "rating": "7.7",
    "price": "158",
    "currency": "USD",
    "taxesAndFees": "+US$25 taxes and fees",
    "roomName": "Standard Studio (2 Adults) Entire studio - 1 bathroom - 1 kitchen - 22 m2",
    "checkInDate": "2026-08-20",
    "checkOutDate": "2026-08-22",
    "adults": "2",
    "rank": "2",
    "imageUrls": "[\"https://cf.bstatic.com/xdata/images/hotel/square240/759499775.webp\"]",
    "scrapedAt": "2026-07-10T20:21:05.242338+00:00"
}
```

Fields like `address`, `city`, `amenities`, and `description` are included when the page variant Booking.com serves contains them; otherwise they stay empty rather than being filled with guesses. The actor never emits fake rows: if a page is blocked or has no listing data, it records the failure in the run summary instead of inventing results.

### 💰 How much does it cost to scrape Booking.com?

Based on a measured cloud run, scraping **1,000 hotel results uses about 0.74 compute units, roughly $0.30** of platform usage on the Apify Starter plan ($0.40 per CU).

Residential proxy bandwidth is the larger share: the same measured run used about 0.27 GB per 1,000 results, roughly $2.20 at the standard $8/GB residential rate. All in, plan for **around $2.50 per 1,000 hotel results**. Small runs cost proportionally: a 25-hotel test run consumed about $0.06 total, so the free plan's monthly credit is plenty for testing and small extractions.

### ⭐️ Need reviews, not listings?

This actor focuses on hotel inventory and pricing. If you need **guest review text and ratings**, pair it with [Tripadvisor Reviews Scraper](https://apify.com/automly/tripadvisor-reviews-scraper) — it extracts full review text, ratings, dates, reviewer profiles, and owner responses for hotels, restaurants, and attractions.

### ❓ FAQ

#### Do I need a Booking.com account?

No. The actor scrapes public pages without authentication of any kind.

#### Why do I need a residential proxy?

Booking.com protects its pages with a JavaScript bot challenge that blocks most datacenter IPs outright. The actor runs a real browser to pass the challenge, and residential IPs pass it far more reliably. Set `proxyGroups` to `["RESIDENTIAL"]` for consistent results.

#### How many hotels does one search return?

One search URL returns the first page of results, which is around 25 hotels. To cover more of a city, add several more specific searches: by district, neighborhood, or landmark. Each runs as its own search URL and the results land in the same dataset.

#### What export formats are supported?

Everything the Apify platform offers: JSON, CSV, Excel (XLSX), XML, and RSS. Download from the Dataset tab in the Console or fetch programmatically through the Apify API.

#### Can I integrate Booking.com Hotel Scraper with other apps?

Yes. Through Apify integrations it connects to Zapier, Make, Slack, Google Sheets, Google Drive, GitHub, LangChain, and more. You can also use webhooks to trigger an action whenever a run finishes — for example, append fresh prices to a spreadsheet every morning.

#### Can I run it on a schedule or call it from my code?

Yes. Use Apify Schedules to run it daily or weekly, which is the usual setup for price monitoring. You can also start runs and fetch results via the Apify REST API or the JavaScript and Python clients — see the **API** tab on this page for ready-made code examples.

#### Why did my run return no results?

The most common cause is running without residential proxy, in which case Booking.com serves a bot challenge instead of listings. Check the run log and the `OUTPUT` record in the key-value store: the actor documents exactly which URLs were blocked and why. Retrying with `"proxyGroups": ["RESIDENTIAL"]` resolves the vast majority of empty runs.

#### Are the prices accurate?

Prices are read from the same public page a visitor sees for your exact dates, guest count, and currency, including the separate taxes-and-fees line. They reflect the moment of the scrape; Booking.com adjusts prices frequently, which is exactly why scheduled monitoring runs are useful.

### 🔗 Related actors

- [Tripadvisor Reviews Scraper](https://apify.com/automly/tripadvisor-reviews-scraper) – extract hotel and restaurant review text, ratings, and reviewer profiles
- [Airbnb Listings Scraper](https://apify.com/automly/airbnb-listings-scraper) – extract Airbnb listings, prices, and ratings for the same destinations
- [Google Maps Scraper](https://apify.com/automly/google-maps-scraper) – scrape hotels, restaurants, and other places with reviews and contact details from Google Maps
- [Shopify Products Scraper](https://apify.com/automly/shopify-products-scraper) – extract product catalogs and prices from any Shopify store

# Actor input Schema

## `searchUrls` (type: `array`):

Full Booking.com search result URLs to scrape. Use public URLs only.

## `hotelUrls` (type: `array`):

Direct public Booking.com hotel page URLs to scrape.

## `locationQuery` (type: `string`):

Optional destination name used to build a basic Booking.com search URL when no search URL is supplied.

## `checkInDate` (type: `string`):

Optional check-in date in YYYY-MM-DD format.

## `checkOutDate` (type: `string`):

Optional check-out date in YYYY-MM-DD format.

## `adults` (type: `integer`):

Number of adult guests.

## `rooms` (type: `integer`):

Number of rooms.

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

Maximum number of hotel records to emit.

## `currency` (type: `string`):

Optional currency code to request, for example USD or EUR.

## `language` (type: `string`):

Optional language/locale to request, for example en-us.

## `requestTimeoutSecs` (type: `integer`):

Timeout for each page request in seconds.

## `useApifyProxy` (type: `boolean`):

Route requests through the proxy configuration available in the actor run.

## `proxyGroups` (type: `array`):

Optional proxy groups to use when proxying is enabled.

## Actor input object example

```json
{
  "searchUrls": [],
  "hotelUrls": [],
  "adults": 2,
  "rooms": 1,
  "maxResults": 50,
  "requestTimeoutSecs": 30,
  "useApifyProxy": true,
  "proxyGroups": []
}
```

# Actor output Schema

## `hotels` (type: `string`):

Scraped hotel listings with name, price, rating, and dates.

## `fullData` (type: `string`):

All extracted fields including location, amenities, and images.

## `runSummary` (type: `string`):

Run status: record count, failures per URL, and verified modes.

# 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 = {
    "searchUrls": [],
    "hotelUrls": [],
    "proxyGroups": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("automly/booking-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 = {
    "searchUrls": [],
    "hotelUrls": [],
    "proxyGroups": [],
}

# Run the Actor and wait for it to finish
run = client.actor("automly/booking-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 '{
  "searchUrls": [],
  "hotelUrls": [],
  "proxyGroups": []
}' |
apify call automly/booking-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Booking.com Hotel Scraper",
        "description": "Extract hotel names, nightly prices, guest ratings, room types, taxes and fees, and photo URLs from Booking.com search results and hotel pages. Search by destination and dates, monitor rates on a schedule, and export to JSON, CSV, or Excel. No Booking.com account needed.",
        "version": "1.0",
        "x-build-id": "JGvsSmm82hQS0nW3q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automly~booking-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automly-booking-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/automly~booking-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automly-booking-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/automly~booking-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automly-booking-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": {
                    "searchUrls": {
                        "title": "Booking.com search URLs",
                        "type": "array",
                        "description": "Full Booking.com search result URLs to scrape. Use public URLs only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "hotelUrls": {
                        "title": "Booking.com hotel URLs",
                        "type": "array",
                        "description": "Direct public Booking.com hotel page URLs to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationQuery": {
                        "title": "Location query",
                        "type": "string",
                        "description": "Optional destination name used to build a basic Booking.com search URL when no search URL is supplied."
                    },
                    "checkInDate": {
                        "title": "Check-in date",
                        "type": "string",
                        "description": "Optional check-in date in YYYY-MM-DD format."
                    },
                    "checkOutDate": {
                        "title": "Check-out date",
                        "type": "string",
                        "description": "Optional check-out date in YYYY-MM-DD format."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of adult guests.",
                        "default": 2
                    },
                    "rooms": {
                        "title": "Rooms",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of rooms.",
                        "default": 1
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of hotel records to emit.",
                        "default": 50
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Optional currency code to request, for example USD or EUR."
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Optional language/locale to request, for example en-us."
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Timeout for each page request in seconds.",
                        "default": 30
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route requests through the proxy configuration available in the actor run.",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Proxy groups",
                        "type": "array",
                        "description": "Optional proxy groups to use when proxying is enabled.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
