# Google Hotels Scraper (`zerobreak/google-hotels-scraper`) Actor

Google Hotels scraper that collects hotel listings, prices, ratings, amenities, and per-vendor booking sources for any destination and date range, so you can monitor accommodation prices and build travel comparison tools.

- **URL**: https://apify.com/zerobreak/google-hotels-scraper.md
- **Developed by:** [ZeroBreak](https://apify.com/zerobreak) (community)
- **Categories:** Travel, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Google Hotels Scraper

Pulls hotel listings from Google Hotels into a structured dataset. Useful for price monitoring, travel research, competitor analysis, and building accommodation comparison tools.

### What it does

Search hotels by destination and date range. Returns property details with prices, ratings, amenities, nearby places, and review breakdowns. Optionally fetches per-vendor booking prices (Booking.com, Expedia, Hotels.com, etc.) for each property.

### Example use cases

- Monitor hotel prices for a destination over time
- Compare prices across vendors for the same hotel
- Research hotel availability and ratings in a city
- Find 5-star hotels with free cancellation under a budget
- Build a travel price tracker or accommodation comparison tool

### Input

| Field | Description | Default |
|-------|-------------|---------|
| `searchQuery` | Destination or hotel query (e.g., "hotels in Paris") | required |
| `checkInDate` | Check-in date in YYYY-MM-DD format | required |
| `checkOutDate` | Check-out date in YYYY-MM-DD format | required |
| `sortBy` | 3=Lowest price, 8=Highest rating, 13=Most reviewed | `3` |
| `minPrice` | Minimum price per night filter | — |
| `maxPrice` | Maximum price per night filter | — |
| `minRating` | 7=3.5+, 8=4.0+, 9=4.5+ guest rating | — |
| `hotelClass` | Minimum star class (2–5) | — |
| `amenities` | Comma-separated amenity codes (e.g., "27,22" for WiFi + pool) | — |
| `freeCancellation` | Return only free-cancellation properties | `false` |
| `ecoCertified` | Return only eco-certified properties | `false` |
| `includeBookingSources` | Fetch per-vendor prices for each hotel | `false` |
| `currency` | Price currency code (e.g., "USD", "EUR", "GBP") | `USD` |
| `language` | Language code (e.g., "en", "fr", "de") | `en` |
| `country` | Country code for geo-targeting | `us` |
| `maxItems` | Max hotels to return | `20` |
| `requestTimeoutSecs` | Per-request timeout | `30` |

#### Common amenity codes

| Code | Amenity |
|------|---------|
| 1 | Fitness centre |
| 2 | Bar |
| 4 | Restaurant |
| 6 | Free breakfast |
| 22 | Pool |
| 27 | Free WiFi |
| 31 | Airport shuttle |

#### Example input

```json
{
  "searchQuery": "hotels in Paris",
  "checkInDate": "2025-09-20",
  "checkOutDate": "2025-09-25",
  "sortBy": 3,
  "minRating": 8,
  "hotelClass": 4,
  "amenities": "27,22",
  "freeCancellation": true,
  "currency": "EUR",
  "maxItems": 30
}
````

### Output

Each hotel is one dataset record:

| Field | Description |
|-------|-------------|
| `hotelName` | Property name |
| `propertyType` | "hotel" or "vacation rental" |
| `hotelDescription` | Short property description |
| `gpsLatitude` / `gpsLongitude` | GPS coordinates |
| `hotelClass` | Star label (e.g., "4-star hotel") |
| `starRating` | Numeric star rating (2–5) |
| `overallRating` | Guest overall rating (0–5) |
| `reviewCount` | Total guest reviews |
| `checkInTime` | Check-in time (e.g., "3:00 PM") |
| `checkOutTime` | Check-out time (e.g., "12:00 PM") |
| `pricePerNight` | Nightly rate (numeric) |
| `pricePerNightDisplay` | Nightly rate (formatted, e.g., "$381") |
| `totalRate` | Total stay cost (numeric) |
| `totalRateDisplay` | Total stay cost (formatted) |
| `currency` | Currency code |
| `amenityCodes` | List of amenity codes |
| `images` | Thumbnail image URLs |
| `ratingsBreakdown` | Star distribution (1–5 star percentages) |
| `reviewsBreakdown` | Sentiment by category (service, location, etc.) |
| `nearbyPlaces` | Points of interest with transit times |
| `detailToken` | Token for booking sources lookup |
| `bookingSources` | Per-vendor prices (if `includeBookingSources: true`) |
| `checkInDate` / `checkOutDate` | Searched dates |
| `scrapedAt` | ISO 8601 timestamp |

#### Booking source object fields

| Field | Description |
|-------|-------------|
| `vendorName` | Booking platform name (e.g., "Booking.com") |
| `vendorIcon` | Vendor logo URL |
| `isSponsored` | True if this is a paid listing |
| `numGuests` | Number of guests the price covers |
| `ratePerNight` | Nightly rate (numeric) |
| `ratePerNightDisplay` | Nightly rate (formatted) |
| `totalRate` | Total rate (numeric) |
| `totalRateDisplay` | Total rate (formatted) |
| `bookingUrl` | Redirect URL to complete booking |

#### Example output

```json
{
  "hotelName": "Four Seasons Hotel George V, Paris",
  "propertyType": "hotel",
  "hotelDescription": "Iconic luxury hotel near the Champs-Elysees with Michelin-starred dining.",
  "gpsLatitude": 48.8731,
  "gpsLongitude": 2.3024,
  "hotelClass": "5-star hotel",
  "starRating": 5,
  "overallRating": 4.8,
  "reviewCount": 6392,
  "checkInTime": "3:00 PM",
  "checkOutTime": "12:00 PM",
  "pricePerNight": 2253.24,
  "pricePerNightDisplay": "$2,253",
  "totalRate": null,
  "totalRateDisplay": null,
  "currency": "USD",
  "amenityCodes": [1, 2, 4, 22, 27],
  "ratingsBreakdown": [
    { "stars": 5, "percent": 90, "count": 6392 },
    { "stars": 4, "percent": 7, "count": 447 }
  ],
  "reviewsBreakdown": [
    { "name": "Service", "sentiment": 0.79, "total_mentioned": 2926, "positive": 1, "negative": 2772 },
    { "name": "Wellness", "sentiment": 0.63, "total_mentioned": 46 }
  ],
  "nearbyPlaces": [
    { "name": "Arc de Triomphe", "transportations": [{ "type": 3, "duration": "7 min" }] }
  ],
  "bookingSources": [
    {
      "vendorName": "Booking.com",
      "isSponsored": false,
      "numGuests": 2,
      "ratePerNight": 2253.24,
      "ratePerNightDisplay": "$2,253",
      "bookingUrl": "https://..."
    }
  ],
  "checkInDate": "2025-09-20",
  "checkOutDate": "2025-09-25",
  "scrapedAt": "2025-06-01T14:32:00+00:00"
}
```

### Notes

- Results paginate automatically up to your `maxItems` limit
- `includeBookingSources: true` makes one extra request per hotel
- `sortBy` options: 3=lowest price, 8=highest rating, 13=most reviewed
- Transportation types in `nearbyPlaces`: 0=walk, 2=transit, 3=taxi/rideshare
- `reviewsBreakdown` sentiment is a 0–1 score (higher = more positive mentions)
- `totalRate` covers the full stay cost and may not always be present depending on the property

# Actor input Schema

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

Destination or hotel search query. Examples: 'Paris hotels', 'hotels in New York', 'beachfront hotels Bali'.

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

Check-in date in YYYY-MM-DD format (e.g., '2025-09-20').

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

Check-out date in YYYY-MM-DD format (e.g., '2025-09-25').

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

Result sort order.

## `minPrice` (type: `integer`):

Minimum nightly rate filter.

## `maxPrice` (type: `integer`):

Maximum nightly rate filter.

## `minRating` (type: `string`):

Minimum guest rating threshold.

## `hotelClass` (type: `string`):

Minimum hotel star class.

## `amenities` (type: `string`):

Comma-separated amenity codes to filter by. Common codes: 1=Gym, 2=Bar, 4=Restaurant, 6=Free breakfast, 22=Pool, 27=Free WiFi, 31=Airport shuttle.

## `freeCancellation` (type: `boolean`):

Return only hotels with free cancellation.

## `ecoCertified` (type: `boolean`):

Return only eco-certified properties.

## `includeBookingSources` (type: `boolean`):

Fetch per-vendor pricing (Booking.com, Expedia, etc.) for each hotel. Requires one extra request per hotel.

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

Price currency code (e.g., 'USD', 'EUR', 'GBP', 'TRY').

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

Language code for results (e.g., 'en', 'de', 'fr', 'tr').

## `country` (type: `string`):

Two-letter country code for geo-targeting (e.g., 'us', 'gb', 'fr').

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

Maximum number of hotels to return.

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

Per-request timeout in seconds.

## Actor input object example

```json
{
  "searchQuery": "hotels in Paris",
  "checkInDate": "2028-09-20",
  "checkOutDate": "2028-09-25",
  "sortBy": "3",
  "freeCancellation": false,
  "ecoCertified": false,
  "includeBookingSources": false,
  "currency": "USD",
  "language": "en",
  "country": "us",
  "maxItems": 20,
  "requestTimeoutSecs": 30
}
```

# 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 = {
    "searchQuery": "hotels in Paris",
    "checkInDate": "2028-09-20",
    "checkOutDate": "2028-09-25",
    "currency": "USD",
    "language": "en",
    "country": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("zerobreak/google-hotels-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 = {
    "searchQuery": "hotels in Paris",
    "checkInDate": "2028-09-20",
    "checkOutDate": "2028-09-25",
    "currency": "USD",
    "language": "en",
    "country": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("zerobreak/google-hotels-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 '{
  "searchQuery": "hotels in Paris",
  "checkInDate": "2028-09-20",
  "checkOutDate": "2028-09-25",
  "currency": "USD",
  "language": "en",
  "country": "us"
}' |
apify call zerobreak/google-hotels-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Hotels Scraper",
        "description": "Google Hotels scraper that collects hotel listings, prices, ratings, amenities, and per-vendor booking sources for any destination and date range, so you can monitor accommodation prices and build travel comparison tools.",
        "version": "0.0",
        "x-build-id": "Gfua0iRBuufIvibzA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zerobreak~google-hotels-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zerobreak-google-hotels-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/zerobreak~google-hotels-scraper/runs": {
            "post": {
                "operationId": "runs-sync-zerobreak-google-hotels-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/zerobreak~google-hotels-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-zerobreak-google-hotels-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": [
                    "searchQuery",
                    "checkInDate",
                    "checkOutDate"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Destination or hotel search query. Examples: 'Paris hotels', 'hotels in New York', 'beachfront hotels Bali'."
                    },
                    "checkInDate": {
                        "title": "Check-in date",
                        "type": "string",
                        "description": "Check-in date in YYYY-MM-DD format (e.g., '2025-09-20')."
                    },
                    "checkOutDate": {
                        "title": "Check-out date",
                        "type": "string",
                        "description": "Check-out date in YYYY-MM-DD format (e.g., '2025-09-25')."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "3",
                            "8",
                            "13"
                        ],
                        "type": "string",
                        "description": "Result sort order.",
                        "default": "3"
                    },
                    "minPrice": {
                        "title": "Min price (per night)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum nightly rate filter."
                    },
                    "maxPrice": {
                        "title": "Max price (per night)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum nightly rate filter."
                    },
                    "minRating": {
                        "title": "Minimum guest rating",
                        "enum": [
                            "7",
                            "8",
                            "9"
                        ],
                        "type": "string",
                        "description": "Minimum guest rating threshold."
                    },
                    "hotelClass": {
                        "title": "Hotel star class",
                        "enum": [
                            "2",
                            "3",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Minimum hotel star class."
                    },
                    "amenities": {
                        "title": "Amenities filter",
                        "type": "string",
                        "description": "Comma-separated amenity codes to filter by. Common codes: 1=Gym, 2=Bar, 4=Restaurant, 6=Free breakfast, 22=Pool, 27=Free WiFi, 31=Airport shuttle."
                    },
                    "freeCancellation": {
                        "title": "Free cancellation only",
                        "type": "boolean",
                        "description": "Return only hotels with free cancellation.",
                        "default": false
                    },
                    "ecoCertified": {
                        "title": "Eco-certified only",
                        "type": "boolean",
                        "description": "Return only eco-certified properties.",
                        "default": false
                    },
                    "includeBookingSources": {
                        "title": "Include booking sources",
                        "type": "boolean",
                        "description": "Fetch per-vendor pricing (Booking.com, Expedia, etc.) for each hotel. Requires one extra request per hotel.",
                        "default": false
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Price currency code (e.g., 'USD', 'EUR', 'GBP', 'TRY').",
                        "default": "USD"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code for results (e.g., 'en', 'de', 'fr', 'tr').",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two-letter country code for geo-targeting (e.g., 'us', 'gb', 'fr').",
                        "default": "us"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of hotels to return.",
                        "default": 20
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
