# Tripadvisor Reviews Scraper — Ratings, Text & Owner Replies (`khadinakbar/tripadvisor-reviews-scraper`) Actor

Scrape all reviews from any Tripadvisor hotel, restaurant, or attraction URL — rating, title, text, trip type, date of stay, reviewer, helpful votes, and owner responses. Auto-paginates. MCP-ready.

- **URL**: https://apify.com/khadinakbar/tripadvisor-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 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

## Tripadvisor Reviews Scraper

Scrape **every review** from any Tripadvisor **hotel, restaurant, or attraction** page — just paste the listing URL. Returns clean, structured JSON with the rating, title, full review text, trip type, date of stay, reviewer name and location, helpful votes, and the owner/management response. Auto-paginates through the whole review history. Built for AI agents (MCP-ready) and analysts alike.

### What it does

Give it one or more Tripadvisor listing URLs and it returns one row per review. It handles the three main listing types Tripadvisor exposes:

- **Hotels** (`/Hotel_Review-...`)
- **Restaurants** (`/Restaurant_Review-...`)
- **Attractions / things to do** (`/Attraction_Review-...`)

It walks the review pages in order (`-or10`, `-or20`, …) until it reaches your `maxReviewsPerUrl` cap or runs out of reviews, so you get the full review history, not just the first page.

### When to use it

- **Reputation monitoring** — track new reviews and owner replies for your own or competitor properties.
- **Sentiment & NLP corpora** — pull thousands of reviews to feed a sentiment model, topic model, or LLM summary.
- **Market & location research** — compare guest sentiment across hotels, restaurants, or attractions in a city.
- **AI agents** — a natural single-URL-in, structured-JSON-out tool. Ask an agent to "get the latest Tripadvisor reviews for this hotel" and it can call this actor directly via MCP.

**When NOT to use it:** this scrapes reviews for a *known* listing URL. To *search* for listings (find hotels in a city, get ratings/prices/contact info), use the companion [tripadvisor-scraper](https://apify.com/khadinakbar/tripadvisor-scraper).

### Output

One dataset record per review:

| Field | Description |
|---|---|
| `reviewId` | Tripadvisor's internal review ID |
| `listingName` | Name of the hotel/restaurant/attraction |
| `listingUrl` | The listing URL you provided |
| `rating` | Star rating, 1–5 |
| `title` | Review headline |
| `text` | Full review body (expanded past "Read more") |
| `tripType` | Family, Couples, Solo, Business, Friends (hotels) |
| `dateOfStay` | Month/period of the visit |
| `publishedDate` | When the review was written |
| `reviewerName` | Reviewer display name |
| `reviewerLocation` | Reviewer home town (when shown) |
| `reviewerContributions` | Number of reviews the reviewer has posted |
| `helpfulVotes` | How many users found the review helpful |
| `ownerResponse` | Management/owner reply text (when present) |
| `ownerResponseDate` | Date of the owner reply |
| `reviewUrl` | Direct link to the individual review |
| `scrapedAt` | ISO 8601 scrape timestamp |

#### Example record

```json
{
  "reviewId": "1066352123",
  "listingName": "The Michelangelo New York",
  "listingUrl": "https://www.tripadvisor.com/Hotel_Review-g60763-d93589-Reviews-...",
  "rating": 5,
  "title": "My stay at the Michelangelo",
  "text": "The Michelangelo is an oasis in the heart of Manhattan. Very quiet and staff especially courteous...",
  "tripType": "family",
  "dateOfStay": "June 2026",
  "publishedDate": "Jun 2026",
  "reviewerName": "Marcus P P",
  "reviewerLocation": "New Brunswick, New Jersey",
  "reviewerContributions": 4,
  "helpfulVotes": 0,
  "ownerResponse": null,
  "reviewUrl": "https://www.tripadvisor.com/ShowUserReviews-g60763-d93589-r1066352123-...",
  "scrapedAt": "2026-07-01T12:35:02.068Z"
}
````

### Pricing

**Pay per result.** You are charged **$0.003 per review** returned, plus a tiny actor-start fee. No monthly rental, no subscription. A 100-review pull costs about **$0.30**. Your `maxReviewsPerUrl` setting is your hard cost cap — the actor prints the maximum cost at the start of every run and the actual billed amount at the end.

| Event | Price |
|---|---|
| Review scraped | $0.003 |
| Actor start | $0.00005 (per GB RAM) |

### Input

```json
{
  "startUrls": [
    { "url": "https://www.tripadvisor.com/Hotel_Review-g60763-d93589-Reviews-The_Michelangelo-New_York_City_New_York.html" }
  ],
  "maxReviewsPerUrl": 50
}
```

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array of `{ url }` | — | Tripadvisor hotel/restaurant/attraction listing URLs |
| `maxReviewsPerUrl` | integer | 20 | Max reviews to collect per listing |
| `proxyConfiguration` | object | Residential US | Proxy settings (leave as default) |

### Using it from an AI agent (MCP)

This actor is exposed through the [Apify MCP server](https://mcp.apify.com) as `khadinakbar/tripadvisor-reviews-scraper`. An agent can call it with a single listing URL and receive structured review JSON back — ideal for "summarize the latest reviews for X" workflows.

### Using it via API

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("khadinakbar/tripadvisor-reviews-scraper").call(run_input={
    "startUrls": [{"url": "https://www.tripadvisor.com/Restaurant_Review-g60763-d425787-Reviews-Katz_s_Deli-New_York_City_New_York.html"}],
    "maxReviewsPerUrl": 50,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["rating"], item["title"])
```

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('khadinakbar/tripadvisor-reviews-scraper').call({
    startUrls: [{ url: 'https://www.tripadvisor.com/Attraction_Review-g60763-d104365-Reviews-Empire_State_Building-New_York_City_New_York.html' }],
    maxReviewsPerUrl: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### How to get a listing URL

Open the hotel, restaurant, or attraction on [tripadvisor.com](https://www.tripadvisor.com), then copy the URL from your browser's address bar. It looks like `.../Hotel_Review-g60763-d93589-Reviews-....html`. Paste that into `startUrls`. Any `-orNN` page suffix is stripped automatically, so it doesn't matter which review page you copy from.

### Notes & limitations

- **Reviews are returned newest-first**, matching Tripadvisor's default order.
- `tripType` and `dateOfStay` are populated for hotel reviews; attractions and restaurants expose fewer of these fields, so they may be `null`.
- Some reviewers hide their home town, so `reviewerLocation` can be `null`.
- Tripadvisor is protected by DataDome bot mitigation. This actor clears it with residential US proxies and a browser warm-up, and **auto-escalates to a DataImpulse residential fallback tier** if IPs get persistently challenged. On the rare occasion when every proxy IP is still blocked, the run finishes with a single `_blocked` record and a clear message — just retry in 10–15 minutes.

### FAQ

**Can I scrape multiple listings in one run?** Yes — add as many URLs to `startUrls` as you like. `maxReviewsPerUrl` applies per listing.

**Does it get the full review text or just the preview?** Full text — it reads the complete review body, not the truncated "Read more" preview.

**Does it include owner/management responses?** Yes, when present (`ownerResponse` + `ownerResponseDate`).

**How many reviews can it get?** As many as the listing has; set `maxReviewsPerUrl` accordingly. Large pulls take longer because each review page is loaded through a real browser.

**Which countries/languages?** Any Tripadvisor domain listing works. Reviews are returned as displayed on the listing's default (usually English) review view.

### Legal

This actor collects only publicly available data from Tripadvisor listing pages. You are responsible for how you use the data. Comply with Tripadvisor's Terms of Use, applicable copyright, and data-protection laws (including GDPR/CCPA) — in particular, do not use reviewer names or other personal data in ways that violate privacy law. This tool is provided for lawful research, monitoring, and analysis purposes.

# Actor input Schema

## `startUrls` (type: `array`):

One or more Tripadvisor detail URLs to scrape reviews from — hotels (Hotel\_Review), restaurants (Restaurant\_Review), or attractions (Attraction\_Review). Paste the main listing page; any '-orNN' pagination suffix is stripped automatically. Example: https://www.tripadvisor.com/Hotel\_Review-g60763-d93589-Reviews-The\_Standard\_High\_Line-New\_York\_City\_New\_York.html . NOT a Tripadvisor search or city page — use a single listing's page.

## `maxReviewsPerUrl` (type: `integer`):

Maximum number of reviews to collect for each listing URL before moving on. Pagination stops early when the listing has fewer reviews. Defaults to 20. Set higher (e.g. 200) for a full review history; each review is billed, so this is your primary cost control. NOT a global cap across all URLs — it applies per listing.

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

Proxy settings. Defaults to Apify Residential proxies pinned to the US, which is required to clear Tripadvisor's DataDome bot protection. Only change this if you know a different region works better for your target listings.

## `proxyProvider` (type: `string`):

Which proxy tier to use against Tripadvisor's DataDome protection. 'auto' (default) uses Apify Residential US and auto-escalates to the DataImpulse residential fallback if IPs get persistently blocked. 'apify' forces Apify Residential only. 'dataimpulse' forces the DataImpulse fallback tier. The DataImpulse tiers require the DATAIMPULSE\_PROXY secret to be set on the actor; without it, everything falls back to Apify Residential.

## `debug` (type: `boolean`):

When true, writes the raw Tripadvisor review object structure to the key-value store (REVIEW\_STRUCTURE\_DEBUG) for troubleshooting field mapping. Leave false for normal runs. NOT needed unless reviews come back empty or with missing fields.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.tripadvisor.com/Hotel_Review-g60763-d93589-Reviews-The_Standard_High_Line-New_York_City_New_York.html"
    }
  ],
  "maxReviewsPerUrl": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "proxyProvider": "auto",
  "debug": false
}
```

# Actor output Schema

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

One record per review with reviewId, rating, title, text, tripType, dateOfStay, publishedDate, reviewerName, reviewerLocation, helpfulVotes, ownerResponse, language, and listingUrl.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.tripadvisor.com/Hotel_Review-g60763-d93589-Reviews-The_Standard_High_Line-New_York_City_New_York.html"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/tripadvisor-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 = {
    "startUrls": [{ "url": "https://www.tripadvisor.com/Hotel_Review-g60763-d93589-Reviews-The_Standard_High_Line-New_York_City_New_York.html" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/tripadvisor-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 '{
  "startUrls": [
    {
      "url": "https://www.tripadvisor.com/Hotel_Review-g60763-d93589-Reviews-The_Standard_High_Line-New_York_City_New_York.html"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call khadinakbar/tripadvisor-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tripadvisor Reviews Scraper — Ratings, Text & Owner Replies",
        "description": "Scrape all reviews from any Tripadvisor hotel, restaurant, or attraction URL — rating, title, text, trip type, date of stay, reviewer, helpful votes, and owner responses. Auto-paginates. MCP-ready.",
        "version": "0.1",
        "x-build-id": "rd96v5ZoT1ShkbefR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~tripadvisor-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-tripadvisor-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~tripadvisor-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-tripadvisor-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~tripadvisor-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-tripadvisor-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Tripadvisor listing URLs",
                        "type": "array",
                        "description": "One or more Tripadvisor detail URLs to scrape reviews from — hotels (Hotel_Review), restaurants (Restaurant_Review), or attractions (Attraction_Review). Paste the main listing page; any '-orNN' pagination suffix is stripped automatically. Example: https://www.tripadvisor.com/Hotel_Review-g60763-d93589-Reviews-The_Standard_High_Line-New_York_City_New_York.html . NOT a Tripadvisor search or city page — use a single listing's page.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxReviewsPerUrl": {
                        "title": "Max reviews per listing",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect for each listing URL before moving on. Pagination stops early when the listing has fewer reviews. Defaults to 20. Set higher (e.g. 200) for a full review history; each review is billed, so this is your primary cost control. NOT a global cap across all URLs — it applies per listing.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Defaults to Apify Residential proxies pinned to the US, which is required to clear Tripadvisor's DataDome bot protection. Only change this if you know a different region works better for your target listings.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    },
                    "proxyProvider": {
                        "title": "Proxy provider (advanced)",
                        "enum": [
                            "auto",
                            "apify",
                            "dataimpulse"
                        ],
                        "type": "string",
                        "description": "Which proxy tier to use against Tripadvisor's DataDome protection. 'auto' (default) uses Apify Residential US and auto-escalates to the DataImpulse residential fallback if IPs get persistently blocked. 'apify' forces Apify Residential only. 'dataimpulse' forces the DataImpulse fallback tier. The DataImpulse tiers require the DATAIMPULSE_PROXY secret to be set on the actor; without it, everything falls back to Apify Residential.",
                        "default": "auto"
                    },
                    "debug": {
                        "title": "Debug: dump review payload structure",
                        "type": "boolean",
                        "description": "When true, writes the raw Tripadvisor review object structure to the key-value store (REVIEW_STRUCTURE_DEBUG) for troubleshooting field mapping. Leave false for normal runs. NOT needed unless reviews come back empty or with missing fields.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
