# TripAdvisor URL: Hotels, Restaurants, Attractions, Reviews (`jdtpnjtp/tripadvisor-url-parser`) Actor

Paste any TripAdvisor URL - hotel, restaurant, attraction, listing, reviews page or destination - and the actor auto-detects the type and returns the full structured payload. The only universal TripAdvisor URL parser on Apify Store.

- **URL**: https://apify.com/jdtpnjtp/tripadvisor-url-parser.md
- **Developed by:** [Data Forge](https://apify.com/jdtpnjtp) (community)
- **Categories:** Travel, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 tripadvisor url parsed (location / lightweight)s

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

## TripAdvisor URL Parser

The only universal TripAdvisor URL parser on Apify Store. Drop in any TripAdvisor URL - hotel detail, restaurant page, attraction listing, reviews page, geo landing - and the actor auto-detects the page type and returns the matching structured payload. Optionally pulls reviews for every hotel / restaurant / attraction URL in the same run, so one input covers both the place and its reviews. No more wiring up six different scrapers to handle six URL patterns. One actor, one input, one consistent dataset.

Built for growth teams scraping competitor inventory, travel-research analysts pulling thousands of locations, and engineers who want one API for every TripAdvisor surface. Drop a URL → get a row (or, with reviews enabled, a row plus N more).

### What it does

- Accepts **1 to 500 TripAdvisor URLs** in a single run.
- Auto-detects the page type from the URL pattern - **8 supported types** (hotel detail, restaurant detail, attraction detail, reviews, hotels listing, restaurants listing, attractions listing, geo landing).
- Works across **9 locales**: `.com`, `.co.uk`, `.de`, `.fr`, `.es`, `.it`, `.ca`, `.com.au`, `.co.jp`.
- **Optional reviews fan-out:** for any hotel / restaurant / attraction URL the actor can paginate reviews (up to 5,000 per place) and emit each review as its own dataset row - ready for SQL / Pandas / Excel without extra parsing.
- Survives mid-batch failures with `stopOnError=false` (default): failing URLs are recorded inline with `error_code` and the run continues.
- Per-event pricing - only pay for what you actually scrape. Cheap geo lookups stay cheap, reviews bill per row.

### Input

```json
{
  "urls": [
    "https://www.tripadvisor.com/Hotel_Review-g60763-d1218720-Reviews-The_Plaza-New_York_City_New_York.html",
    "https://www.tripadvisor.com/Restaurants-g187147-Paris_Ile_de_France.html",
    "https://www.tripadvisor.com/Attraction_Review-g187147-d188151-Reviews-Eiffel_Tower-Paris_Ile_de_France.html"
  ],
  "stopOnError": false,
  "maxReviewsPerEntity": 20,
  "reviewLanguage": "en",
  "reviewSort": "most_relevant"
}
````

| Field | Type | Required | Description |
|---|---|---|---|
| **`urls`** | array of strings | ✅ | 1-500 TripAdvisor URLs from any of the 9 supported locales |
| `stopOnError` | boolean | optional, default `false` | If `true`, abort the run on the first failing URL. Default skips and records the failure inline |
| `maxReviewsPerEntity` | integer 0-5000 | optional, default `0` | When set above `0`, every hotel / restaurant / attraction URL also fans out into per-review rows (up to this many per place). Each review charges `url-parsed-review` at $0.001. Ignored for destination / listing / reviews-page URLs |
| `reviewLanguage` | string | optional, default `en` | TripAdvisor language code (e.g. `en`, `fr`, `de`, `es`, `it`, `ja`, `zh`) or `all`. Applied only when `maxReviewsPerEntity > 0` |
| `reviewSort` | enum | optional, default `most_relevant` | One of: `most_relevant`, `newest`, `oldest`, `highest`, `lowest`. Applied only when `maxReviewsPerEntity > 0` |

### Output

One dataset row per input URL (plus one row per fanned-out review when `maxReviewsPerEntity > 0`). On success, `type` and `data` are populated; on failure, `error_code` and `error_message` are populated instead.

#### Detail row example

```json
{
  "input_url": "https://www.tripadvisor.com/Hotel_Review-g60763-d1218720-Reviews-The_Plaza-New_York_City_New_York.html",
  "type": "hotel_detail",
  "data": {
    "location_id": 1218720,
    "name": "The Plaza",
    "rating": 4.5,
    "review_count": 1487,
    "address": "768 5th Ave, New York City, NY 10019",
    "amenities": ["Free Wifi", "Bar/lounge", "Concierge"],
    "rooms": [{"name": "Deluxe King", "price_min": 895}],
    "photos": [{"url": "https://media-cdn.tripadvisor.com/.../photo.jpg"}]
  }
}
```

#### Per-review row example (when `maxReviewsPerEntity > 0`)

```json
{
  "input_url": "https://www.tripadvisor.com/Hotel_Review-g60763-d1218720-Reviews-The_Plaza-New_York_City_New_York.html",
  "type": "review",
  "parent_type": "hotel_detail",
  "parent_location_id": "1218720",
  "data": {
    "rating": 5,
    "title": "Outstanding stay",
    "text": "Beautiful suite, attentive staff…",
    "language": "en",
    "traveler_type": "couples",
    "published_date": "2026-04-12",
    "helpful_votes": 3,
    "photos": []
  }
}
```

`parent_location_id` is what you JOIN on to link reviews back to their parent hotel / restaurant / attraction row in the same dataset.

#### Console table view

| 🔗 URL | 🏷 Type | 📦 Payload | 🪪 Parent location ID | ❌ Error |
|---|---|---|---|---|
| `…/Hotel_Review-…/The_Plaza.html` | `hotel_detail` | 17 fields incl. rooms + photos | - | - |
| `…/Hotel_Review-…/The_Plaza.html` | `review` | one review (rating, text, language, …) | `1218720` | - |
| `…/Restaurants-g187147-…` | `restaurants_listing` | paginated restaurant cards | - | - |
| `…/Attraction_Review-…/Eiffel_Tower.html` | `attraction_detail` | 14 fields incl. awards | - | - |
| `…/Hotel_Review-…/BrokenLink.html` | - | - | - | `NOT_FOUND` |

#### What `data` contains by `type`

| Type | Payload |
|---|---|
| `hotel_detail` | 17 fields: location\_id, name, rating, review\_count, address, amenities\[], rooms\[], photos\[], lowest\_offer + OTA prices |
| `restaurant_detail` | 15 fields: id, name, cuisine, price\_range, hours, location, photos\[] |
| `attraction_detail` | 14-15 fields: id, name, category, duration, awards\[], reviews\_count |
| `review` | one review row (rating, title, text, language, traveler\_type, published\_date, helpful\_votes, photos) with `parent_type` + `parent_location_id` set |
| `reviews` | paginated reviews page (when the URL itself is a `…-Reviews-orN-…` page) |
| `hotels_listing` / `restaurants_listing` / `attractions_listing` | full SERP for the geo with filters applied |
| `location` | destination metadata (name, geoId, region, country, photos) |

#### Error codes

| `error_code` | Meaning |
|---|---|
| `NOT_FOUND` | TripAdvisor returned no payload for this URL (deleted listing, broken slug, regional removal) |
| `UPSTREAM_BLOCKED` | Anti-bot challenge wasn't bypassed - retry the run later |
| `INVALID_URL` | URL didn't match any known TripAdvisor pattern |
| `INTERNAL_ERROR` | Something else broke - see `error_message` |

### More TripAdvisor tools

Part of the USP Ultimate TripAdvisor suite - pick the actor that fits the job:

- **[TripAdvisor Hotels, Restaurants & Cruises Scraper](https://apify.com/jdtpnjtp/tripadvisor)** - search a whole destination across 5 verticals (hotels, restaurants, things to do, vacation rentals, cruises).
- **[TripAdvisor Reviews Scraper](https://apify.com/jdtpnjtp/tripadvisor-reviews-bulk)** - bulk-pull every review from a list of hotels, restaurants or attractions.

Prefer the raw API across all 21 TripAdvisor endpoints with your own key? See the USP Ultimate TripAdvisor API on RapidAPI.

### Need help? Enterprise plans? Custom scraping?

I personally support every customer - drop a message on any channel.

[![Telegram](https://img.shields.io/badge/Telegram-2CA5E0?style=for-the-badge\&logo=telegram\&logoColor=white)](https://t.me/j4dtpnj2tp)
[![WhatsApp](https://img.shields.io/badge/WhatsApp-25D366?style=for-the-badge\&logo=whatsapp\&logoColor=white)](https://wa.me/380686031542)
[![Email](https://img.shields.io/badge/Email-D14836?style=for-the-badge\&logo=gmail\&logoColor=white)](mailto:jdtpnjtp@gmail.com)

# Actor input Schema

## `urls` (type: `array`):

One or more TripAdvisor URLs to parse. Supports every locale domain (.com / .co.uk / .de / .fr / .es / .it / .ca / .com.au / .co.jp).

## `stopOnError` (type: `boolean`):

If true, the actor stops as soon as a URL fails to parse (NOT\_FOUND, malformed URL, blocked upstream). If false (default), failing URLs are skipped with the error recorded inline.

## `maxReviewsPerEntity` (type: `integer`):

When set above 0, for every hotel / restaurant / attraction URL the actor also pulls reviews and emits each review as a separate dataset row (carries `type: 'review'` and `parent_location_id`). Set to 0 to disable. Each review charges the `url-parsed-review` event ($0.001). Common values: 20 = quick sample, 100 = decent dataset, 500 = deep mining.

## `reviewLanguage` (type: `string`):

Language of reviews to keep when the fan-out is on. Pick **All languages** or a specific language; you can also type any TripAdvisor language code (e.g. `cs`, `th`). Only applied when `maxReviewsPerEntity > 0`.

## `reviewSort` (type: `string`):

Sort order applied when paginating reviews. Only used when `maxReviewsPerEntity > 0`.

## Actor input object example

```json
{
  "urls": [
    "https://www.tripadvisor.com/Hotel_Review-g60763-d1218720-Reviews-The_Plaza-New_York_City_New_York.html",
    "https://www.tripadvisor.com/Restaurants-g187147-Paris_Ile_de_France.html"
  ],
  "stopOnError": false,
  "maxReviewsPerEntity": 20,
  "reviewLanguage": "en",
  "reviewSort": "most_relevant"
}
```

# Actor output Schema

## `dataset` (type: `string`):

The default dataset. Each row carries `input_url`, `type` (8 supported types) and `data` (the type-specific structured payload). Failed URLs land here too with `error_code` + `error_message` populated instead of `data`.

## `summary` (type: `string`):

A single JSON object written to the default key-value store under the OUTPUT key. Contains urls\_received, urls\_succeeded, urls\_failed, detail\_charged, light\_charged, reviews\_charged, estimated\_cost\_usd, limit\_reached, and actor\_version.

# 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 = {
    "urls": [
        "https://www.tripadvisor.com/Hotel_Review-g60763-d1218720-Reviews-The_Plaza-New_York_City_New_York.html",
        "https://www.tripadvisor.com/Restaurants-g187147-Paris_Ile_de_France.html"
    ],
    "maxReviewsPerEntity": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("jdtpnjtp/tripadvisor-url-parser").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 = {
    "urls": [
        "https://www.tripadvisor.com/Hotel_Review-g60763-d1218720-Reviews-The_Plaza-New_York_City_New_York.html",
        "https://www.tripadvisor.com/Restaurants-g187147-Paris_Ile_de_France.html",
    ],
    "maxReviewsPerEntity": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("jdtpnjtp/tripadvisor-url-parser").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 '{
  "urls": [
    "https://www.tripadvisor.com/Hotel_Review-g60763-d1218720-Reviews-The_Plaza-New_York_City_New_York.html",
    "https://www.tripadvisor.com/Restaurants-g187147-Paris_Ile_de_France.html"
  ],
  "maxReviewsPerEntity": 20
}' |
apify call jdtpnjtp/tripadvisor-url-parser --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TripAdvisor URL: Hotels, Restaurants, Attractions, Reviews",
        "description": "Paste any TripAdvisor URL - hotel, restaurant, attraction, listing, reviews page or destination - and the actor auto-detects the type and returns the full structured payload. The only universal TripAdvisor URL parser on Apify Store.",
        "version": "1.1",
        "x-build-id": "YeGkrMVTjmzjL4iyr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jdtpnjtp~tripadvisor-url-parser/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jdtpnjtp-tripadvisor-url-parser",
                "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/jdtpnjtp~tripadvisor-url-parser/runs": {
            "post": {
                "operationId": "runs-sync-jdtpnjtp-tripadvisor-url-parser",
                "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/jdtpnjtp~tripadvisor-url-parser/run-sync": {
            "post": {
                "operationId": "run-sync-jdtpnjtp-tripadvisor-url-parser",
                "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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "TripAdvisor URLs",
                        "minItems": 1,
                        "maxItems": 500,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "One or more TripAdvisor URLs to parse. Supports every locale domain (.com / .co.uk / .de / .fr / .es / .it / .ca / .com.au / .co.jp).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "stopOnError": {
                        "title": "Stop on first error",
                        "type": "boolean",
                        "description": "If true, the actor stops as soon as a URL fails to parse (NOT_FOUND, malformed URL, blocked upstream). If false (default), failing URLs are skipped with the error recorded inline.",
                        "default": false
                    },
                    "maxReviewsPerEntity": {
                        "title": "Max reviews per hotel / restaurant / attraction",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "When set above 0, for every hotel / restaurant / attraction URL the actor also pulls reviews and emits each review as a separate dataset row (carries `type: 'review'` and `parent_location_id`). Set to 0 to disable. Each review charges the `url-parsed-review` event ($0.001). Common values: 20 = quick sample, 100 = decent dataset, 500 = deep mining.",
                        "default": 0
                    },
                    "reviewLanguage": {
                        "title": "Review language",
                        "type": "string",
                        "description": "Language of reviews to keep when the fan-out is on. Pick **All languages** or a specific language; you can also type any TripAdvisor language code (e.g. `cs`, `th`). Only applied when `maxReviewsPerEntity > 0`.",
                        "default": "en"
                    },
                    "reviewSort": {
                        "title": "Review sort order",
                        "enum": [
                            "most_relevant",
                            "newest",
                            "oldest",
                            "highest",
                            "lowest"
                        ],
                        "type": "string",
                        "description": "Sort order applied when paginating reviews. Only used when `maxReviewsPerEntity > 0`.",
                        "default": "most_relevant"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```