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

Scrape Agoda hotel guest reviews by hotel URL or ID — rating, title, text, pros/cons, reviewer profile, hotel response, and dates. HTTP-only, MCP-ready.

- **URL**: https://apify.com/khadinakbar/agoda-reviews-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Travel, MCP servers, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 review scrapeds

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

Scrape **Agoda hotel guest reviews** by hotel URL or hotel ID — rating, title, full text, pros/cons, reviewer profile, traveler type, room type, hotel response, and dates. HTTP-only, fast, and **MCP-ready** for AI agents.

### What it does

Give it one or more Agoda hotel pages (or numeric hotel IDs) and it returns every guest review as a clean, flat JSON record. It reads Agoda's own review API directly — no browser, no login — and paginates through the full review history per hotel, up to your chosen limit. Optionally pulls reviews from **all aggregated providers** (Agoda + partner sources) for maximum coverage.

### When to use it

- **Hotel & OTA revenue managers** monitoring guest sentiment on their own and competitor properties.
- **Hospitality analysts** building rating trend and review-volume datasets.
- **Market researchers** mining traveler-type, country, and room-type breakdowns.
- **AI agents / LLM pipelines** that need structured review data from a single tool call.

Do **not** use it for hotel prices/availability or search results — this actor returns reviews only. One hotel URL per entry (not a city or search URL).

### Output

One dataset item per review:

| Field | Description |
|---|---|
| `hotelId` | Numeric Agoda hotel ID |
| `hotelReviewId` | Unique review ID |
| `rating` | Score 0–10 |
| `ratingText` | Agoda label (e.g. "Exceptional") |
| `reviewTitle` | Review headline |
| `reviewText` | Main review body |
| `positives` | "Liked" text (when present) |
| `negatives` | "Disliked" text (when present) |
| `reviewDate` | ISO 8601 review timestamp |
| `checkInDate` | ISO 8601 check-in date |
| `checkInMonthYear` | Human-readable stay month |
| `lengthOfStay` | Nights stayed |
| `helpfulVotes` | Helpful-vote count |
| `reviewerName` | Display name |
| `reviewerCountry` | Reviewer country |
| `travelerType` | Solo / Couple / Family / Business, etc. |
| `roomType` | Room type stayed in |
| `language` | Original review language code |
| `provider` | Source (Agoda, Booking.com, etc.) |
| `providerId` | Numeric provider ID |
| `hotelResponderName` | Hotel's responder name (if the hotel replied) |
| `hotelResponseDate` | Date of the hotel's response |
| `images` | Guest-uploaded image URLs |
| `scrapedAt` | ISO 8601 scrape timestamp |

### Pricing

Pay-per-event:

- **Actor start** — $0.00005 per run.
- **Review scraped** — **$0.003 per review** returned.

100 reviews ≈ $0.30. Costs are capped by `maxReviewsPerHotel` and shown in the run log/status before charging begins. Both event-based and usage-based billing are available; pick whichever fits at run time.

### Input

| Field | Type | Notes |
|---|---|---|
| `hotelUrls` | array | Agoda hotel page URLs. hotelId auto-extracted. |
| `hotelIds` | array | Numeric hotel IDs (skips the page fetch, faster). |
| `maxReviewsPerHotel` | integer | Default 100. Set high/0 to pull all. |
| `sortBy` | enum | `most_recent` (default), `most_helpful`, `highest_rated`, `lowest_rated`. |
| `includeAllProviders` | boolean | Pull partner-provider reviews too. Default false. |
| `onlyReviewsWithText` | boolean | Skip rating-only entries. Default false. |
| `proxyConfiguration` | object | Defaults to Apify Residential (required). |

#### Example input

```json
{
  "hotelUrls": [
    "https://www.agoda.com/the-berkeley-hotel-pratunam/hotel/bangkok-th.html"
  ],
  "maxReviewsPerHotel": 200,
  "sortBy": "most_recent",
  "includeAllProviders": false
}
````

#### Direct hotel IDs

```json
{
  "hotelIds": ["461790"],
  "maxReviewsPerHotel": 500,
  "sortBy": "most_helpful"
}
```

### Usage from the API (Node.js)

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('khadinakbar/agoda-reviews-scraper').call({
    hotelIds: ['461790'],
    maxReviewsPerHotel: 100,
    sortBy: 'most_recent',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Usage from Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("khadinakbar/agoda-reviews-scraper").call(run_input={
    "hotelIds": ["461790"],
    "maxReviewsPerHotel": 100,
    "sortBy": "most_recent",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["rating"], item["reviewTitle"])
```

### MCP / AI agents

Exposed through Apify MCP as `khadinakbar/agoda-reviews-scraper`. It takes a hotel URL or ID and returns structured review JSON — a natural single tool call for Claude, ChatGPT, or any agent doing hospitality research or sentiment analysis. Charged $0.003 per review.

### How it works

The actor calls Agoda's public `ReviewComments` endpoint over plain HTTP through Apify Residential proxies, paces requests to respect Agoda's rate limits, and paginates until it reaches your `maxReviewsPerHotel` cap or exhausts the reviews. Reviews are de-duplicated by review ID. When a hotel returns nothing after repeated attempts, that hotel is skipped and logged in the `RUN_SUMMARY` key-value record; if every hotel is blocked, the run fails honestly rather than reporting a false success.

### FAQ

**How do I find a hotel ID?** Open the hotel on Agoda; the numeric `hotelId` is in the page URL query string or page source. Or just pass the full hotel URL and the actor extracts it.

**Can I get all reviews for a large hotel?** Yes — set `maxReviewsPerHotel` high (or `0`). Large hotels have tens of thousands of reviews; the run will take longer and cost more.

**Why residential proxies?** Agoda rate-limits datacenter IPs aggressively. Residential is the default and recommended setting.

**Does it get reviews in English?** Agoda returns each review with its original text; the language code is in the `language` field.

**Are hotel responses included?** When a hotel has publicly replied, `hotelResponderName` and `hotelResponseDate` are populated.

### Legal

This actor collects only **publicly available** review data from Agoda's own review endpoints. It performs no login and accesses no private or personal account data. You are responsible for using the output in compliance with Agoda's Terms of Service, applicable data-protection laws (including GDPR/CCPA where relevant), and any restrictions on personal data. Use for lawful research, analytics, and monitoring purposes only.

# Actor input Schema

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

Agoda hotel page URLs to scrape reviews from (e.g. 'https://www.agoda.com/the-berkeley-hotel-pratunam/hotel/bangkok-th.html'). The actor auto-extracts the numeric hotelId from each page. Accepts any Agoda locale/subpath. NOT a search or city URL — pass one URL per hotel. Leave empty if you supply hotelIds instead.

## `hotelIds` (type: `array`):

Numeric Agoda hotel IDs to scrape directly, skipping the page fetch (e.g. '461790'). Find the ID in the hotel URL query string or page source. Faster than hotelUrls because no HTML page is downloaded. NOT the property name or a booking ID — must be the numeric hotelId.

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

Maximum number of reviews to collect per hotel before stopping. Controls run cost since each review is a billable event. Defaults to 100. Set 0 or a very high number to attempt all available reviews (large hotels have tens of thousands). Applies per hotel, not across the whole run.

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

Order in which Agoda returns reviews. 'most\_recent' pulls newest first (best for monitoring). 'most\_helpful' pulls Agoda's top-voted reviews. 'highest\_rated'/'lowest\_rated' sort by score. Defaults to 'most\_recent'. Does not change which reviews exist, only their order and thus which ones you get first under a maxReviewsPerHotel cap.

## `includeAllProviders` (type: `boolean`):

Agoda aggregates reviews from Agoda plus partner sources (e.g. Booking.com). When true, the actor iterates every available provider for each hotel to maximize coverage. When false (default) it scrapes only Agoda's own reviews, which are the largest and most consistent set. Turn on for maximum volume, off for cleaner Agoda-native data.

## `onlyReviewsWithText` (type: `boolean`):

When true, skips rating-only entries that have no written comment, positives, or negatives. Useful for sentiment analysis where empty reviews add noise. When false (default) every review is returned, including score-only ones. Filtering happens after fetch, so it does not reduce billing on the fetched page.

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

Proxy settings. Defaults to Apify Residential proxies, which are required — Agoda rate-limits datacenter IPs. Leave as default unless you have a specific reason to change it.

## Actor input object example

```json
{
  "hotelUrls": [
    "https://www.agoda.com/the-berkeley-hotel-pratunam/hotel/bangkok-th.html"
  ],
  "hotelIds": [
    "461790"
  ],
  "maxReviewsPerHotel": 100,
  "sortBy": "most_recent",
  "includeAllProviders": false,
  "onlyReviewsWithText": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

All scraped Agoda reviews as JSON.

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

End-of-run stats (hotels processed, totals, skipped).

# 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": [
        "https://www.agoda.com/the-berkeley-hotel-pratunam/hotel/bangkok-th.html"
    ],
    "maxReviewsPerHotel": 100,
    "sortBy": "most_recent"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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": ["https://www.agoda.com/the-berkeley-hotel-pratunam/hotel/bangkok-th.html"],
    "maxReviewsPerHotel": 100,
    "sortBy": "most_recent",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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": [
    "https://www.agoda.com/the-berkeley-hotel-pratunam/hotel/bangkok-th.html"
  ],
  "maxReviewsPerHotel": 100,
  "sortBy": "most_recent"
}' |
apify call khadinakbar/agoda-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Agoda Reviews Scraper",
        "description": "Scrape Agoda hotel guest reviews by hotel URL or ID — rating, title, text, pros/cons, reviewer profile, hotel response, and dates. HTTP-only, MCP-ready.",
        "version": "1.0",
        "x-build-id": "4ovgtJNtVMlYT5zbS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~agoda-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~agoda-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~agoda-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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": "Agoda hotel page URLs to scrape reviews from (e.g. 'https://www.agoda.com/the-berkeley-hotel-pratunam/hotel/bangkok-th.html'). The actor auto-extracts the numeric hotelId from each page. Accepts any Agoda locale/subpath. NOT a search or city URL — pass one URL per hotel. Leave empty if you supply hotelIds instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "hotelIds": {
                        "title": "Agoda hotel IDs",
                        "type": "array",
                        "description": "Numeric Agoda hotel IDs to scrape directly, skipping the page fetch (e.g. '461790'). Find the ID in the hotel URL query string or page source. Faster than hotelUrls because no HTML page is downloaded. NOT the property name or a booking ID — must be the numeric hotelId.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerHotel": {
                        "title": "Max reviews per hotel",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect per hotel before stopping. Controls run cost since each review is a billable event. Defaults to 100. Set 0 or a very high number to attempt all available reviews (large hotels have tens of thousands). Applies per hotel, not across the whole run.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "most_recent",
                            "most_helpful",
                            "highest_rated",
                            "lowest_rated"
                        ],
                        "type": "string",
                        "description": "Order in which Agoda returns reviews. 'most_recent' pulls newest first (best for monitoring). 'most_helpful' pulls Agoda's top-voted reviews. 'highest_rated'/'lowest_rated' sort by score. Defaults to 'most_recent'. Does not change which reviews exist, only their order and thus which ones you get first under a maxReviewsPerHotel cap.",
                        "default": "most_recent"
                    },
                    "includeAllProviders": {
                        "title": "Include all review providers",
                        "type": "boolean",
                        "description": "Agoda aggregates reviews from Agoda plus partner sources (e.g. Booking.com). When true, the actor iterates every available provider for each hotel to maximize coverage. When false (default) it scrapes only Agoda's own reviews, which are the largest and most consistent set. Turn on for maximum volume, off for cleaner Agoda-native data.",
                        "default": false
                    },
                    "onlyReviewsWithText": {
                        "title": "Only reviews with text",
                        "type": "boolean",
                        "description": "When true, skips rating-only entries that have no written comment, positives, or negatives. Useful for sentiment analysis where empty reviews add noise. When false (default) every review is returned, including score-only ones. Filtering happens after fetch, so it does not reduce billing on the fetched page.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Defaults to Apify Residential proxies, which are required — Agoda rate-limits datacenter IPs. Leave as default unless you have a specific reason to change it.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
