# Hospitality Reviews AI Analyzer (`marketsignals/hospitality-reviews-ai-analyzer`) Actor

Analyze and compare customer reviews from Google and TripAdvisor for restaurants, hotels, and tourist attractions. This Actor identifies recurring complaints, positive themes, platform-specific perception gaps, and generates a business-ready reputation report with recommended actions.

- **URL**: https://apify.com/marketsignals/hospitality-reviews-ai-analyzer.md
- **Developed by:** [yc DATALAB](https://apify.com/marketsignals) (community)
- **Categories:** AI, Automation, Travel
- **Stats:** 2 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Hospitality Reviews AI Analyzer

Analyze and compare customer reviews from **Google Reviews** and **TripAdvisor** for restaurants, hotels, and tourist attractions.

This Actor turns review data into a clear business report showing recurring complaints, positive themes, platform-specific perception gaps, and recommended actions.

It is designed for hospitality businesses, agencies, consultants, tourism professionals, and anyone who wants to understand customer perception across review platforms.

---

### What this Actor does

This Actor analyzes review data and generates a structured reputation report including:

* Key review metrics
* Average rating by source
* Sentiment overview
* Most frequent positive themes
* Most frequent negative themes
* Google vs TripAdvisor comparison
* Platform-specific perception gaps
* Business interpretation
* Recommended actions
* Suggested replies to common negative reviews

The main goal is not only to summarize reviews, but to explain what each platform reveals.

For example:

* Google may highlight practical or operational issues such as service, waiting time, parking, or accessibility.
* TripAdvisor may highlight tourist experience, perceived value, price, atmosphere, or overall travel expectations.

---

### Supported sources

The Actor supports:

* Google Reviews data
* TripAdvisor Reviews data
* Google + TripAdvisor combined analysis

You can provide only one source, or both sources for a cross-platform comparison.

---

### How reviews are collected

You can either **provide review data yourself** or let the Actor **collect it automatically** from a public URL:

* **Provided data** — paste JSON, link a CSV URL, or pick an Apify dataset. The Actor analyzes exactly what you give it.
* **Automatic scraping** — provide a **Google Maps URL** and/or a **TripAdvisor URL**. The Actor then delegates the scraping to specialized, battle-tested community Actors (via `Actor.call`), waits for them to finish, reads their dataset and feeds the reviews into the same analysis pipeline.

Typical automatic flow:

````

Google Maps URL + TripAdvisor URL
→ automatic scraping (child Actors)
→ normalization + sentiment/theme analysis
→ cross-platform comparison
→ business report (JSON + Markdown)

````

The child Actor identifiers are configurable through the `GOOGLE_REVIEWS_SCRAPER_ACTOR_ID` and `TRIPADVISOR_REVIEWS_SCRAPER_ACTOR_ID` environment variables. Automatic scraping requires the Actor to run with permission to call other Actors; when it runs under limited permissions the scraping step fails gracefully and the run continues with any other available source.

Users are responsible for ensuring they have the right to use and process the review data they collect or provide.

---

### Input options

You can provide review data in several ways. For each platform the highest-priority source available is used, in this order: **inline JSON → CSV URL → Apify dataset ID → automatic scraping from a URL**. A scraper is never launched when data is already provided for that platform.

#### 1. Inline JSON

You can paste review objects directly into the Actor input.

#### 2. CSV URL

You can provide a public CSV URL containing review data.

#### 3. Apify Dataset ID

You can provide a dataset ID from another compatible Apify Actor (for example the output of a Google Maps or TripAdvisor reviews scraper). Use the **dataset picker** on the `apifyDatasetIdGoogle` and `apifyDatasetIdTripadvisor` fields to select your datasets: this automatically grants the Actor read access at runtime, even when it runs under limited permissions.

#### 4. Automatic scraping from a URL

Provide a public `googleMapsUrl` and/or `tripadvisorUrl`. Control the volume and language with `maxGoogleReviews`, `maxTripadvisorReviews`, `scrapingLanguage` (`fr`, `en`, `es`, or `all`) and cap the spend per source with `maxScrapingCostUsdPerSource`. The report's `scrapingMetadata` field and the **Data collection** section of the Markdown report record how each source was collected.

---

### Recommended input fields

Each review should ideally contain:

* `rating`
* `review_text`
* `review_title`
* `published_date`
* `visit_date`
* `language`
* `owner_response`
* `reviewer_name`

The Actor will try to normalize different field names automatically.

---

### Business types

The Actor supports different theme sets depending on the type of business:

* Restaurant
* Hotel
* Tourist attraction
* Generic business

Restaurant reports can detect themes such as service, waiting time, food, price, atmosphere, noise, cleanliness, location, parking, authenticity, and tourist experience.

Hotel reports can detect themes such as cleanliness, bedding, noise, reception, breakfast, room, bathroom, location, parking, value for money, air conditioning, view, service, and tourist experience.

Attraction reports can detect themes such as price, waiting time, accessibility, organization, visit interest, guide quality, crowding, cleanliness, reception, tourist experience, and value for money.

---

### Output

The Actor generates:

* A structured JSON result in the default dataset
* A Markdown report saved as `REPORT.md`
* A full JSON report saved as `REPORT.json`

The Markdown report includes:

* Executive summary
* Google Reviews analysis
* TripAdvisor Reviews analysis
* Cross-platform comparison
* Important perception gaps
* Business interpretation
* Strengths and weaknesses
* Recommended actions
* Suggested review replies
* Limitations

---

### Example use cases

#### Restaurants

Compare what local customers say on Google with what visitors say on TripAdvisor.

Useful for detecting whether complaints are mostly operational, price-related, or linked to tourist expectations.

#### Hotels

Analyze differences between practical guest feedback and travel-experience feedback.

Useful for identifying issues around cleanliness, bedding, breakfast, noise, staff, or perceived value.

#### Tourist attractions

Understand what visitors praise or criticize most often.

Useful for detecting problems related to waiting time, organization, crowding, pricing, guide quality, or accessibility.

---

### Example insights

The Actor can generate conclusions such as:

* “TripAdvisor concentrates complaints related to price and value for money, suggesting a perception issue among tourists.”
* “Service appears more often in Google reviews, suggesting a local or operational friction point.”
* “Waiting time is visible on both platforms, but sentiment is more negative on TripAdvisor.”
* “Google and TripAdvisor reveal different parts of the customer experience.”

---

### Pricing suggestion

This Actor is designed to support pay-per-report or pay-per-result pricing.

A combined Google + TripAdvisor report generally provides more value than a single-source report because it compares platform-specific perception gaps.

---

### Limitations

* The current version uses rules, keyword detection, and structured analysis.
* It does not use generative AI by default.
* It does not scrape Google or TripAdvisor itself; automatic scraping is delegated to specialized child Actors and requires permission to call other Actors.
* The quality of the report depends on the quality and volume of the input reviews.
* Small datasets may produce less reliable conclusions.
* For best results, use at least 50 reviews per source when possible.

---

### Best for

* Restaurants
* Hotels
* Tourist attractions
* Hospitality consultants
* Reputation management agencies
* Local SEO specialists
* Tourism businesses
* Customer feedback analysts

---

### Output language

The report can be generated in:

* French
* English
* Spanish

# Actor input Schema

## `businessName` (type: `string`):

Name of the restaurant, hotel or attraction being analyzed. Used only for labelling the report.
## `businessType` (type: `string`):

Type of establishment. Controls which themes are used to classify reviews.
## `outputLanguage` (type: `string`):

Language used for the generated report and business conclusions.
## `googleReviewsCsvUrl` (type: `string`):

Public URL to a CSV file containing Google reviews.
## `tripadvisorReviewsCsvUrl` (type: `string`):

Public URL to a CSV file containing TripAdvisor reviews.
## `googleReviewsJson` (type: `array`):

Google reviews provided directly as an array of objects.
## `tripadvisorReviewsJson` (type: `array`):

TripAdvisor reviews provided directly as an array of objects.
## `apifyDatasetIdGoogle` (type: `string`):

Select an Apify dataset containing Google reviews.
## `apifyDatasetIdTripadvisor` (type: `string`):

Select an Apify dataset containing TripAdvisor reviews.
## `googleMapsUrl` (type: `string`):

Public Google Maps URL of the establishment. When set (and no Google reviews are provided directly), reviews are scraped automatically via a specialized Apify Actor.
## `tripadvisorUrl` (type: `string`):

Public TripAdvisor URL of the establishment. When set (and no TripAdvisor reviews are provided directly), reviews are scraped automatically via a specialized Apify Actor.
## `maxGoogleReviews` (type: `integer`):

Maximum number of Google reviews to request from the scraper when using automatic scraping.
## `maxTripadvisorReviews` (type: `integer`):

Maximum number of TripAdvisor reviews to request from the scraper when using automatic scraping.
## `scrapingLanguage` (type: `string`):

Preferred language of reviews collected via automatic scraping. Use "all" to collect reviews in every available language.
## `maxScrapingCostUsdPerSource` (type: `number`):

Optional cost cap forwarded to each child scraper run when the called Actor supports it. Helps keep automatic scraping within budget.
## `maxReviewsPerSource` (type: `integer`):

Maximum number of reviews to analyze per source (0 = unlimited).
## `includeSuggestedReplies` (type: `boolean`):

Generate template owner replies for the main negative themes.
## `includeActionPlan` (type: `boolean`):

Generate a concrete list of recommended actions based on the analysis.

## Actor input object example

```json
{
  "businessName": "Le Petit Bistro",
  "businessType": "generic",
  "outputLanguage": "fr",
  "googleMapsUrl": "https://www.google.com/maps/place/...",
  "tripadvisorUrl": "https://www.tripadvisor.com/Restaurant_Review-...",
  "maxGoogleReviews": 1000,
  "maxTripadvisorReviews": 1000,
  "scrapingLanguage": "all",
  "maxScrapingCostUsdPerSource": 5,
  "maxReviewsPerSource": 2000,
  "includeSuggestedReplies": true,
  "includeActionPlan": true
}
````

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("marketsignals/hospitality-reviews-ai-analyzer").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("marketsignals/hospitality-reviews-ai-analyzer").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 '{}' |
apify call marketsignals/hospitality-reviews-ai-analyzer --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hospitality Reviews AI Analyzer",
        "description": "Analyze and compare customer reviews from Google and TripAdvisor for restaurants, hotels, and tourist attractions. This Actor identifies recurring complaints, positive themes, platform-specific perception gaps, and generates a business-ready reputation report with recommended actions.",
        "version": "0.1",
        "x-build-id": "kIqP9O4KwS7py90lv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/marketsignals~hospitality-reviews-ai-analyzer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-marketsignals-hospitality-reviews-ai-analyzer",
                "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/marketsignals~hospitality-reviews-ai-analyzer/runs": {
            "post": {
                "operationId": "runs-sync-marketsignals-hospitality-reviews-ai-analyzer",
                "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/marketsignals~hospitality-reviews-ai-analyzer/run-sync": {
            "post": {
                "operationId": "run-sync-marketsignals-hospitality-reviews-ai-analyzer",
                "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": {
                    "businessName": {
                        "title": "Business name",
                        "type": "string",
                        "description": "Name of the restaurant, hotel or attraction being analyzed. Used only for labelling the report."
                    },
                    "businessType": {
                        "title": "Business type",
                        "enum": [
                            "restaurant",
                            "hotel",
                            "attraction",
                            "generic"
                        ],
                        "type": "string",
                        "description": "Type of establishment. Controls which themes are used to classify reviews.",
                        "default": "generic"
                    },
                    "outputLanguage": {
                        "title": "Output language",
                        "enum": [
                            "fr",
                            "en",
                            "es"
                        ],
                        "type": "string",
                        "description": "Language used for the generated report and business conclusions.",
                        "default": "fr"
                    },
                    "googleReviewsCsvUrl": {
                        "title": "Google reviews CSV URL",
                        "type": "string",
                        "description": "Public URL to a CSV file containing Google reviews."
                    },
                    "tripadvisorReviewsCsvUrl": {
                        "title": "TripAdvisor reviews CSV URL",
                        "type": "string",
                        "description": "Public URL to a CSV file containing TripAdvisor reviews."
                    },
                    "googleReviewsJson": {
                        "title": "Google reviews (JSON)",
                        "type": "array",
                        "description": "Google reviews provided directly as an array of objects."
                    },
                    "tripadvisorReviewsJson": {
                        "title": "TripAdvisor reviews (JSON)",
                        "type": "array",
                        "description": "TripAdvisor reviews provided directly as an array of objects."
                    },
                    "apifyDatasetIdGoogle": {
                        "title": "Google reviews Apify dataset",
                        "type": "string",
                        "description": "Select an Apify dataset containing Google reviews."
                    },
                    "apifyDatasetIdTripadvisor": {
                        "title": "TripAdvisor reviews Apify dataset",
                        "type": "string",
                        "description": "Select an Apify dataset containing TripAdvisor reviews."
                    },
                    "googleMapsUrl": {
                        "title": "Google Maps URL",
                        "type": "string",
                        "description": "Public Google Maps URL of the establishment. When set (and no Google reviews are provided directly), reviews are scraped automatically via a specialized Apify Actor."
                    },
                    "tripadvisorUrl": {
                        "title": "TripAdvisor URL",
                        "type": "string",
                        "description": "Public TripAdvisor URL of the establishment. When set (and no TripAdvisor reviews are provided directly), reviews are scraped automatically via a specialized Apify Actor."
                    },
                    "maxGoogleReviews": {
                        "title": "Max Google reviews to scrape",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of Google reviews to request from the scraper when using automatic scraping.",
                        "default": 1000
                    },
                    "maxTripadvisorReviews": {
                        "title": "Max TripAdvisor reviews to scrape",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of TripAdvisor reviews to request from the scraper when using automatic scraping.",
                        "default": 1000
                    },
                    "scrapingLanguage": {
                        "title": "Scraping language",
                        "enum": [
                            "fr",
                            "en",
                            "es",
                            "all"
                        ],
                        "type": "string",
                        "description": "Preferred language of reviews collected via automatic scraping. Use \"all\" to collect reviews in every available language.",
                        "default": "all"
                    },
                    "maxScrapingCostUsdPerSource": {
                        "title": "Max scraping cost per source (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Optional cost cap forwarded to each child scraper run when the called Actor supports it. Helps keep automatic scraping within budget.",
                        "default": 5
                    },
                    "maxReviewsPerSource": {
                        "title": "Max reviews per source",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to analyze per source (0 = unlimited).",
                        "default": 2000
                    },
                    "includeSuggestedReplies": {
                        "title": "Include suggested replies",
                        "type": "boolean",
                        "description": "Generate template owner replies for the main negative themes.",
                        "default": true
                    },
                    "includeActionPlan": {
                        "title": "Include action plan",
                        "type": "boolean",
                        "description": "Generate a concrete list of recommended actions based on the analysis.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```