# Agoda Reviews Scraper (`fetch_cat/agoda-reviews-scraper`) Actor

Scrape public Agoda hotel reviews with ratings, dates, traveler types, room types, reviewer countries, and property context.

- **URL**: https://apify.com/fetch\_cat/agoda-reviews-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / 1,000 review extracteds

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

## Agoda Reviews Scraper

Collect public Agoda hotel reviews, ratings, traveler metadata, stay dates, and property context for travel affiliate pages, programmatic SEO, and reputation monitoring.

### What does Agoda Reviews Scraper do?

Agoda Reviews Scraper turns public Agoda hotel pages into structured review datasets. Provide Agoda hotel URLs or known property IDs and the actor saves one row per review with the review text, score, title, date, stay information, traveler type, room type, reviewer country, and hotel-level rating context.

Use it when you need review content for destination pages, hotel comparison pages, sentiment monitoring, or QA checks across multiple Agoda properties.

### Who is it for?

- 🧳 Travel affiliate operators building hotel and destination pages.
- 🏨 Hotel reputation teams monitoring guest feedback.
- 🔎 SEO teams enriching programmatic landing pages with public review signals.
- 📊 Analysts comparing guest sentiment across properties, countries, and room types.
- 🤖 AI workflow builders feeding hotel reviews into summarization or alerting pipelines.

### Why use it?

Agoda has rich hotel review coverage, but manual copy-paste does not scale. This actor creates export-ready data that can be loaded into spreadsheets, BI tools, vector stores, databases, or affiliate content pipelines.

### Typical use cases

- Build review snippets for destination pages.
- Track new negative reviews for a hotel portfolio.
- Compare traveler types such as families, couples, and solo travelers.
- Monitor room-type-specific complaints.
- Generate AI summaries from recent guest feedback.
- Refresh public review context before publishing travel guides.

### Input overview

You can start with Agoda hotel URLs, Agoda property IDs, or both. The easiest path is to paste one or more hotel URLs into `hotelUrls` and set `maxReviewsPerHotel` to a small number for a first run.

### Agoda hotel URLs

Use full public Agoda hotel URLs, for example:

```json
{
  "hotelUrls": [
    { "url": "https://www.agoda.com/marina-bay-sands/hotel/singapore-sg.html" }
  ],
  "maxReviewsPerHotel": 10
}
````

### Agoda property IDs

If your system already stores Agoda property IDs, provide them directly:

```json
{
  "propertyIds": [185945],
  "maxReviewsPerHotel": 10
}
```

### Review sorting

Choose one of these sort modes:

- `mostHelpful` — Agoda's most helpful order.
- `mostRecent` — newest reviews first.
- `highestRating` — rating high to low.
- `lowestRating` — rating low to high.

### Language and currency

The `language` and `currency` inputs are sent while loading Agoda pages. Use values such as `en-us`, `de-de`, `ja-jp`, and `USD`, `EUR`, `SGD`, or `JPY`. Review text may include Agoda-provided translations where Agoda exposes them publicly.

### Output data

Each dataset row represents one review.

| Field | Description |
| --- | --- |
| `hotelUrl` | Source Agoda hotel page when a URL was supplied |
| `propertyId` | Agoda hotel/property ID |
| `hotelName` | Hotel name from Agoda review data |
| `city` | Best-effort city parsed from the URL |
| `country` | Best-effort country code parsed from the URL |
| `overallRating` | Hotel-level Agoda rating |
| `totalReviews` | Hotel-level review count when available |
| `reviewId` | Agoda review identifier |
| `reviewTitle` | Review title |
| `reviewText` | Review body |
| `rating` | Numeric review rating |
| `ratingText` | Agoda rating label |
| `reviewDate` | Review date |
| `stayDate` | Stay/check-in date when available |
| `travelerType` | Traveler group, e.g. family or couple |
| `roomType` | Room type named in the review |
| `reviewerName` | Public reviewer display name |
| `reviewerCountry` | Reviewer country |
| `provider` | Review provider shown by Agoda |
| `scrapedAt` | Timestamp when the row was saved |

### Example output

```json
{
  "hotelUrl": "https://www.agoda.com/marina-bay-sands/hotel/singapore-sg.html",
  "propertyId": 185945,
  "hotelName": "Marina Bay Sands",
  "overallRating": 8.9,
  "reviewId": "1072507195",
  "reviewTitle": "You absolutely have to stay here when you come to Singapore!",
  "reviewText": "It was absolutely amazing...",
  "rating": 10,
  "reviewDate": "2026-02-04T02:50:00.000Z",
  "travelerType": "Family with young children",
  "roomType": "Sands Premier King Room",
  "reviewerCountry": "Japan",
  "provider": "Agoda",
  "scrapedAt": "2026-06-19T00:00:00.000Z"
}
```

### How much does it cost to scrape Agoda reviews?

This actor uses pay-per-event pricing. You pay a small run start fee and a per-review fee for saved review rows. The first production price is calibrated from cloud cost measurements before publishing. Keep first tests small, then increase `maxReviewsPerHotel` after confirming the data shape.

### How to run

1. Open the actor on Apify.
2. Paste one or more Agoda hotel URLs.
3. Set `maxReviewsPerHotel`.
4. Choose a sort order.
5. Click **Start**.
6. Download results from the default dataset as JSON, CSV, Excel, XML, or RSS.

### Tips for best results

- Start with 5-10 reviews per hotel for a first run.
- Use `mostRecent` for monitoring workflows.
- Use `lowestRating` to detect complaints and service issues.
- Use property IDs when you already maintain an Agoda hotel catalog.
- Use proxy settings if Agoda blocks requests from your environment.

### Integrations

- Send review rows to Google Sheets for editorial review.
- Export CSV for BI dashboards.
- Connect the dataset API to a vector database for semantic search.
- Use webhooks to trigger Slack alerts on fresh negative reviews.
- Combine with hotel or maps actors for destination-page enrichment.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/agoda-reviews-scraper').call({
  hotelUrls: [{ url: 'https://www.agoda.com/marina-bay-sands/hotel/singapore-sg.html' }],
  maxReviewsPerHotel: 10,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/agoda-reviews-scraper').call(run_input={
    'hotelUrls': [{'url': 'https://www.agoda.com/marina-bay-sands/hotel/singapore-sg.html'}],
    'maxReviewsPerHotel': 10,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~agoda-reviews-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"hotelUrls":[{"url":"https://www.agoda.com/marina-bay-sands/hotel/singapore-sg.html"}],"maxReviewsPerHotel":10}'
```

### MCP usage

Use this actor from MCP-enabled tools through Apify MCP Server. Example prompts:

- "Scrape the latest Agoda reviews for this hotel and summarize common complaints."
- "Find low-rated Agoda reviews for these five hotels and group them by room type."
- "Create a table of reviewer countries and traveler types from this Agoda hotel."

MCP endpoint pattern:

```text
https://mcp.apify.com/?tools=fetch_cat/agoda-reviews-scraper
```

Claude Code setup example:

```bash
claude mcp add apify-agoda-reviews "https://mcp.apify.com/?tools=fetch_cat/agoda-reviews-scraper"
```

Claude Desktop JSON configuration example:

```json
{
  "mcpServers": {
    "apify-agoda-reviews": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/agoda-reviews-scraper"
    }
  }
}
```

### Data quality notes

Agoda review availability varies by hotel, locale, and review provider. Some reviews have translated text, some have original-language text, and some fields such as room type or reviewer name may be missing when Agoda does not display them.

### Limits

The actor caps `maxReviewsPerHotel` to 500 in v0.1 to keep runs predictable. For very large backfills, run multiple hotels in batches and monitor run duration and dataset size.

### Troubleshooting

If a run saves no reviews, check that the hotel URL is public and still available on Agoda. If Agoda blocks the request, enable Apify Proxy or try a different proxy group. If a field is blank, Agoda likely did not expose that field for the specific review.

### Legality

### Legal and ethical use

This actor extracts publicly available information from Agoda pages. Use the data responsibly, respect applicable laws, and avoid collecting or storing data you do not have a legitimate reason to process. Do not use scraped content for spam, deception, or harmful profiling.

### Related scrapers

Other Anna actors can complement Agoda review data for travel workflows:

- Airbnb data actors for accommodation market analysis.
- Google Maps review actors for local reputation monitoring.
- YouTube video actors for destination content research.

### FAQ

#### Can I scrape multiple hotels?

Yes. Add multiple Agoda URLs or property IDs and set a per-hotel review cap.

#### Does it require an Agoda account?

No. The actor is designed for public hotel pages and public review data.

#### Can I get only recent reviews?

Use `sort: "mostRecent"` and set the review cap to the number of recent rows you need.

#### Why do some reviews have translated text?

Agoda may provide translated public review text depending on locale and availability.

#### What should I do if Agoda blocks my run?

Use Apify Proxy, keep first runs small, and retry with a suitable proxy location.

### Changelog

- 0.1 — Initial Agoda hotel reviews extraction.

# Actor input Schema

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

Public Agoda hotel pages to scrape reviews from. Use full hotel URLs such as https://www.agoda.com/marina-bay-sands/hotel/singapore-sg.html.

## `propertyIds` (type: `array`):

Optional Agoda numeric property IDs. Use this when you already know the hotelId/propertyId and do not want to provide a hotel URL.

## `maxReviewsPerHotel` (type: `integer`):

Maximum number of reviews to save for each hotel. Keep this low for first tests, then increase for production monitoring.

## `sort` (type: `string`):

How Agoda should sort the review comments before extraction.

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

Locale passed to Agoda, for example en-us, de-de, ja-jp. Review text may include Agoda translations when available.

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

Currency code sent to Agoda while loading hotel pages, for example USD, EUR, SGD, JPY.

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

Optional proxy settings. Datacenter/automatic proxy is usually enough for small tests; use residential only if Agoda blocks your run.

## Actor input object example

```json
{
  "hotelUrls": [
    {
      "url": "https://www.agoda.com/marina-bay-sands/hotel/singapore-sg.html"
    }
  ],
  "propertyIds": [],
  "maxReviewsPerHotel": 10,
  "sort": "mostHelpful",
  "language": "en-us",
  "currency": "USD",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "hotelUrls": [
        {
            "url": "https://www.agoda.com/marina-bay-sands/hotel/singapore-sg.html"
        }
    ],
    "propertyIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/agoda-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "hotelUrls": [{ "url": "https://www.agoda.com/marina-bay-sands/hotel/singapore-sg.html" }],
    "propertyIds": [],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/agoda-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "hotelUrls": [
    {
      "url": "https://www.agoda.com/marina-bay-sands/hotel/singapore-sg.html"
    }
  ],
  "propertyIds": []
}' |
apify call fetch_cat/agoda-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Agoda Reviews Scraper",
        "description": "Scrape public Agoda hotel reviews with ratings, dates, traveler types, room types, reviewer countries, and property context.",
        "version": "0.1",
        "x-build-id": "AWEJfYNcUwnxHI34K"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~agoda-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-agoda-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fetch_cat~agoda-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-agoda-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fetch_cat~agoda-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-agoda-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "hotelUrls": {
                        "title": "Agoda hotel URLs",
                        "type": "array",
                        "description": "Public Agoda hotel pages to scrape reviews from. Use full hotel URLs such as https://www.agoda.com/marina-bay-sands/hotel/singapore-sg.html.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "propertyIds": {
                        "title": "Agoda property IDs",
                        "type": "array",
                        "description": "Optional Agoda numeric property IDs. Use this when you already know the hotelId/propertyId and do not want to provide a hotel URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerHotel": {
                        "title": "Maximum reviews per hotel",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to save for each hotel. Keep this low for first tests, then increase for production monitoring.",
                        "default": 10
                    },
                    "sort": {
                        "title": "Review sorting",
                        "enum": [
                            "mostHelpful",
                            "mostRecent",
                            "highestRating",
                            "lowestRating"
                        ],
                        "type": "string",
                        "description": "How Agoda should sort the review comments before extraction.",
                        "default": "mostHelpful"
                    },
                    "language": {
                        "title": "Language / locale",
                        "type": "string",
                        "description": "Locale passed to Agoda, for example en-us, de-de, ja-jp. Review text may include Agoda translations when available.",
                        "default": "en-us"
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Currency code sent to Agoda while loading hotel pages, for example USD, EUR, SGD, JPY.",
                        "default": "USD"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Datacenter/automatic proxy is usually enough for small tests; use residential only if Agoda blocks your run.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
