# TripAdvisor Scraper – Hotels, Restaurants & Reviews (`khadinakbar/tripadvisor-scraper`) Actor

Extract hotels, restaurants, and attractions from TripAdvisor — including ratings, contact info, amenities, and reviews — from search queries or direct URLs.

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

## Pricing

from $3.00 / 1,000 listing scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Scraper – Hotels, Restaurants & Reviews

### What does this TripAdvisor Scraper do?

This actor extracts structured data from TripAdvisor — hotels, restaurants, attractions, and vacation rentals — including full listing details **and** user reviews, all in a single run. No need to chain two separate actors. Pass a search query like `"hotels in Miami"` or paste direct TripAdvisor URLs and get back clean, structured JSON ready for your pipeline, CRM, or AI agent.

### Why use this TripAdvisor Scraper?

- **All-in-one** — listings + reviews in a single actor run (competitors require two)
- **40% cheaper** than the market leader's free tier at $0.003/listing and $0.001/review
- **B2B-ready output** — includes phone, website, price range, ranking, coordinates, and amenities
- **MCP-optimized** — semantic field names and consistent output shape make it work seamlessly with Claude and other AI agents
- **No login required** — scrapes publicly available data without credentials

### What data does this TripAdvisor Scraper extract?

#### Listing data (record_type: "listing")

| Field | Type | Description |
|---|---|---|
| name | string | Hotel / restaurant / attraction name |
| category | string | Hotel, Restaurant, Attraction, Vacation Rental |
| address | string | Full street address |
| city | string | City |
| country | string | Country |
| phone | string | Contact phone number |
| website | string | External website URL (decoded from TA redirect) |
| rating | number | TripAdvisor rating (1.0–5.0) |
| review_count | integer | Total number of reviews |
| price_range | string | $, $$, $$$, or $$$$ |
| price_level | integer | 1–4 numeric price level |
| ranking | string | Full ranking text, e.g. "#3 of 233 Hotels in Miami Beach" |
| ranking_position | integer | Numeric ranking within location |
| ranking_total | integer | Total properties in category + location |
| description | string | Property description |
| amenities | array | List of amenities (Pool, WiFi, Spa, etc.) |
| cuisines | array | Cuisine types (restaurants only) |
| awards | array | TripAdvisor awards (Travelers' Choice, etc.) |
| latitude | number | GPS latitude |
| longitude | number | GPS longitude |
| photos_count | integer | Number of photos on the listing |
| tripadvisor_id | string | TripAdvisor location ID |
| tripadvisor_url | string | Direct link to the TripAdvisor listing |
| scraped_at | string | ISO 8601 timestamp |
| source_url | string | Page URL scraped |

#### Review data (record_type: "review")

| Field | Type | Description |
|---|---|---|
| listing_name | string | Name of the reviewed property |
| listing_url | string | TripAdvisor URL of the property |
| rating | integer | Star rating (1–5) |
| title | string | Review headline |
| text | string | Full review body (including expanded "read more") |
| date_of_stay | string | When reviewer visited, e.g. "March 2024" |
| travel_type | string | Couples, Families, Solo, Business, Friends |
| reviewer_name | string | TripAdvisor username |
| reviewer_location | string | Reviewer's home location |
| helpful_votes | integer | How many found this review helpful |
| owner_response | string | Management's response to the review |
| scraped_at | string | ISO 8601 timestamp |
| source_url | string | Page URL scraped |

### How to use this TripAdvisor Scraper

#### Option 1: Search by query

```json
{
    "searchQueries": ["hotels in Miami Beach", "restaurants in Paris 1st arrondissement"],
    "scrapeMode": "listings_and_reviews",
    "maxResults": 20,
    "maxReviewsPerListing": 15
}
````

#### Option 2: Scrape specific URLs

```json
{
    "startUrls": [
        { "url": "https://www.tripadvisor.com/Hotel_Review-g294471-d234567-Reviews-The_Setai-Miami_Beach.html" },
        { "url": "https://www.tripadvisor.com/Restaurant_Review-g60763-d1234567-Reviews-Eleven_Madison_Park-New_York_City.html" }
    ],
    "scrapeMode": "listings_and_reviews",
    "maxReviewsPerListing": 50
}
```

#### Option 3: Reviews only

```json
{
    "startUrls": [{ "url": "https://www.tripadvisor.com/Hotel_Review-g294471-d234567-Reviews-MyHotel.html" }],
    "scrapeMode": "reviews_only",
    "maxReviewsPerListing": 200
}
```

#### Via API (Node.js)

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('khadinakbar/tripadvisor-scraper').call({  // replace with your username after first push
    searchQueries: ['hotels in Barcelona'],
    scrapeMode: 'listings_and_reviews',
    maxResults: 10,
    maxReviewsPerListing: 20,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const listings = items.filter(i => i.record_type === 'listing');
const reviews  = items.filter(i => i.record_type === 'review');
console.log(`${listings.length} listings, ${reviews.length} reviews`);
```

#### Via API (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("khadinakbar/tripadvisor-scraper").call(run_input={  ## replace with your username after first push
    "searchQueries": ["restaurants in Rome"],
    "scrapeMode": "listings_and_reviews",
    "maxResults": 15,
    "maxReviewsPerListing": 10,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
listings = [i for i in items if i["record_type"] == "listing"]
reviews  = [i for i in items if i["record_type"] == "review"]
```

### Pricing

This actor uses **pay-per-event pricing** with two event types:

| Event | Price | Description |
|---|---|---|
| Listing scraped | **$0.003** | Each hotel / restaurant / attraction page scraped |
| Review scraped | **$0.001** | Each individual user review extracted |

#### Cost examples

| Task | Listings | Reviews | Total cost |
|---|---|---|---|
| Quick test | 5 | 50 | ~$0.065 |
| City hotel survey | 30 | 0 | ~$0.09 |
| Competitive review audit | 10 | 200 | ~$0.23 |
| Monthly monitoring | 100 | 1,000 | ~$1.30 |

Compared to the market leader (up to $0.005/listing + $0.005/review), this actor saves you **40–80%** on the same data.

### Input configuration

| Parameter | Type | Default | Description |
|---|---|---|---|
| searchQueries | string\[] | — | Search terms, e.g. "hotels in Tokyo" |
| startUrls | URL\[] | — | Direct TripAdvisor listing URLs |
| scrapeMode | string | listings\_and\_reviews | listings\_only, reviews\_only, or listings\_and\_reviews |
| maxResults | integer | 10 | Max listing pages to scrape |
| maxReviewsPerListing | integer | 20 | Reviews per listing (0 = skip reviews) |
| proxyConfiguration | object | Apify residential | Proxy settings — residential recommended for TripAdvisor |

### Proxy requirements

TripAdvisor uses anti-bot measures. **Residential proxies are strongly recommended** and are pre-configured by default. Using datacenter proxies may result in CAPTCHAs or blocks. The Apify residential proxy pool is included in your plan.

### FAQ

**Can I scrape all TripAdvisor categories?**\
Yes — hotels, restaurants, attractions, and vacation rentals are all supported. The actor auto-detects the listing type from the URL.

**Why do some fields come back as null?**\
TripAdvisor doesn't display every field for every listing type. Restaurants don't have hotel amenities; not all hotels list a website. Missing values are always `null`, never empty strings, so your code can filter cleanly.

**How many results can I scrape per run?**\
The actor supports up to 1,000 listings and up to 500 reviews per listing. For very large runs, schedule multiple runs with different search queries.

**Will it break if TripAdvisor updates their design?**\
The actor uses multiple CSS selector fallbacks per field plus `__NEXT_DATA__` JSON extraction, making it more resilient than single-selector scrapers. If TripAdvisor makes breaking changes, the actor will be updated promptly.

**Is this actor MCP-compatible?**\
Yes. The output uses semantic field names and a consistent structure across all records, making it ideal for use with Claude via the Apify MCP server.

**Can I run it on a schedule?**\
Yes — use Apify Schedules to monitor competitor pricing, track review sentiment over time, or maintain a fresh hotel database.

### Use cases

**Hospitality competitive intelligence** — Track competitor ratings, review counts, and amenities across your market. Identify weaknesses in competitor listings to target in your marketing.

**Market research** — Benchmark accommodation prices and quality in new markets before expansion decisions.

**Reputation management** — Monitor your property's reviews in real time. Feed reviews into a sentiment analysis pipeline for early issue detection.

**Travel content creation** — Populate travel guides, blog posts, or recommendation engines with structured property data.

**Lead generation** — Extract business contact information (phone, website) for hospitality-sector B2B outreach.

**AI agent pipelines** — Use with Claude via Apify MCP to answer questions like "find me the top 10 hotels in Lisbon under $$$ with a pool."

### Works great with

- **khadinakbar/shopify-all-in-one-scraper** — Scrape hotel gift shops or destination retail alongside your property research.
- **khadinakbar/google-trends-scraper** — Combine with travel search trend data for demand forecasting.

***

*This actor extracts publicly available data from TripAdvisor. Users are responsible for compliance with applicable laws, TripAdvisor's Terms of Service, and relevant data protection regulations (GDPR, CCPA). Use responsibly and only for lawful purposes.*

Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools.

# Actor input Schema

## `searchQueries` (type: `array`):

Use this field when the user provides search terms like 'hotels in Miami' or 'restaurants in Paris'. Each query is searched on TripAdvisor and top listing URLs are extracted. Use startUrls instead when the user provides direct TripAdvisor URLs.

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

Use this field when the user provides specific TripAdvisor listing URLs (Hotel\_Review, Restaurant\_Review, Attraction\_Review). Do NOT use this when the user describes a destination or topic — use searchQueries for that.

## `scrapeMode` (type: `string`):

listings\_and\_reviews: scrape full listing details plus reviews (default). listings\_only: scrape listing data only, no reviews. reviews\_only: scrape reviews only from provided listing URLs.

## `maxResults` (type: `integer`):

Maximum number of listing pages to scrape. Each listing counts as one billable result. Start with 5–10 to test before scaling up.

## `maxReviewsPerListing` (type: `integer`):

How many reviews to collect per listing (when scrapeMode includes reviews). Set to 0 to skip reviews. Each review counts as one billable result.

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

Proxy settings. Datacenter proxies are used by default (fast and affordable). Switch to residential proxies if you encounter blocks.

## Actor input object example

```json
{
  "searchQueries": [
    "hotels in New York City"
  ],
  "startUrls": [],
  "scrapeMode": "listings_and_reviews",
  "maxResults": 5,
  "maxReviewsPerListing": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Scraped listing and review records. Filter by record\_type: 'listing' or 'review'. Listings include name, rating, review\_count, address, price\_level, amenities. Reviews include reviewer, rating, title, text, date.

# 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 = {
    "searchQueries": [
        "hotels in New York City"
    ],
    "scrapeMode": "listings_and_reviews",
    "maxResults": 5,
    "maxReviewsPerListing": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/tripadvisor-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 = {
    "searchQueries": ["hotels in New York City"],
    "scrapeMode": "listings_and_reviews",
    "maxResults": 5,
    "maxReviewsPerListing": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/tripadvisor-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 '{
  "searchQueries": [
    "hotels in New York City"
  ],
  "scrapeMode": "listings_and_reviews",
  "maxResults": 5,
  "maxReviewsPerListing": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/tripadvisor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TripAdvisor Scraper – Hotels, Restaurants & Reviews",
        "description": "Extract hotels, restaurants, and attractions from TripAdvisor — including ratings, contact info, amenities, and reviews — from search queries or direct URLs.",
        "version": "1.0",
        "x-build-id": "Sv1iaGGtDHOg4LWar"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~tripadvisor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-tripadvisor-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-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-tripadvisor-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-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-tripadvisor-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": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Use this field when the user provides search terms like 'hotels in Miami' or 'restaurants in Paris'. Each query is searched on TripAdvisor and top listing URLs are extracted. Use startUrls instead when the user provides direct TripAdvisor URLs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Direct TripAdvisor URLs",
                        "type": "array",
                        "description": "Use this field when the user provides specific TripAdvisor listing URLs (Hotel_Review, Restaurant_Review, Attraction_Review). Do NOT use this when the user describes a destination or topic — use searchQueries for that.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "scrapeMode": {
                        "title": "Scrape Mode",
                        "enum": [
                            "listings_and_reviews",
                            "listings_only",
                            "reviews_only"
                        ],
                        "type": "string",
                        "description": "listings_and_reviews: scrape full listing details plus reviews (default). listings_only: scrape listing data only, no reviews. reviews_only: scrape reviews only from provided listing URLs.",
                        "default": "listings_and_reviews"
                    },
                    "maxResults": {
                        "title": "Max Listings",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of listing pages to scrape. Each listing counts as one billable result. Start with 5–10 to test before scaling up.",
                        "default": 10
                    },
                    "maxReviewsPerListing": {
                        "title": "Max Reviews per Listing",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many reviews to collect per listing (when scrapeMode includes reviews). Set to 0 to skip reviews. Each review counts as one billable result.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Datacenter proxies are used by default (fast and affordable). Switch to residential proxies if you encounter blocks.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```