# Tripadvisor Reviews Scraper (`automly/tripadvisor-reviews-scraper`) Actor

Extract Tripadvisor reviews from hotel, restaurant, and attraction pages: ratings, full review text, dates, reviewer profiles, and owner responses. Paste listing URLs, set a limit, and export to JSON, CSV, or Excel. Useful for sentiment analysis, market research, and reputation monitoring.

- **URL**: https://apify.com/automly/tripadvisor-reviews-scraper.md
- **Developed by:** [Automly](https://apify.com/automly) (community)
- **Categories:** Travel
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.55 / 1,000 reviews

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 Reviews Scraper

### ⭐️ What does Tripadvisor Reviews Scraper do?

**Tripadvisor Reviews Scraper** extracts **reviews, ratings, review dates, reviewer profiles, and owner responses** from public **Tripadvisor hotel, restaurant, and attraction pages**. Paste one or more listing URLs, set how many reviews you want per listing, and download the results as **JSON, CSV, or Excel** — no Tripadvisor account, no login, no browser automation.

Tripadvisor has no public reviews API, so if you need review data for **sentiment analysis, reputation monitoring, competitor research, or hospitality market studies**, scraping the public pages is the practical route. This actor does it with plain HTTP requests instead of a headless browser, which keeps runs fast (a 40-review run finishes in about 14 seconds) and compute costs low.

### 🧳 What data can I extract?

<table>
<tr>
<td>⭐️ Star rating per review</td>
<td>📝 Review title + full text (not snippets)</td>
</tr>
<tr>
<td>📅 Published date and visit date</td>
<td>🧑 Reviewer name, location, profile URL</td>
</tr>
<tr>
<td>💬 Owner / management responses with dates</td>
<td>👍 Helpful votes and trip type</td>
</tr>
<tr>
<td>🏨 Listing name, type, and URL on every row</td>
<td>🔗 Direct link to each review</td>
</tr>
</table>

### 🎯 Why scrape Tripadvisor reviews?

- **📊 Sentiment analysis** — build datasets of real guest opinions for NLP and brand monitoring
- **🕵️ Competitor research** — see what guests praise and complain about at rival hotels and restaurants
- **📈 Reputation monitoring** — track new reviews and rating trends over time with scheduled runs
- **🏨 Hospitality market studies** — compare review volume and sentiment across a whole neighborhood
- **💬 Response auditing** — check how (and how fast) managements respond to negative reviews

### ⬇️ How to use

1. Open [Tripadvisor Reviews Scraper](https://apify.com/automly/tripadvisor-reviews-scraper) in Apify Console and click **Try for free**.
2. Paste one or more Tripadvisor listing URLs into **Start URLs**. Any public listing page works — hotels, restaurants, or attractions. Copy the URL straight from your browser, for example:
   - Restaurant: `https://www.tripadvisor.com/Restaurant_Review-g60763-d425787-Reviews-Katz_s_Delicatessen-New_York_City_New_York.html`
   - Hotel pages start with `Hotel_Review-...`, attractions with `Attraction_Review-...`
3. Set **Maximum reviews per URL** (default 50, up to 500 per run).
4. Leave **Use Apify Proxy** switched on. Tripadvisor blocks most datacenter IPs, so residential proxy is strongly recommended — add `RESIDENTIAL` to **Proxy groups** if your plan includes it.
5. Click **Start**. Progress and any blocked-page warnings show up in the log.
6. When the run finishes, open the **Output** tab for a clean review table, or download everything from the **Dataset** tab as JSON, CSV, or Excel.

### ⚙️ Input parameters

These match the actor's input schema. Only `startUrls` is required.

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `startUrls` | array | Yes | Tripadvisor listing or review page URLs to scrape. |
| `maxReviewsPerUrl` | integer | No | Maximum reviews to save per start URL. Default 50, max 500. |
| `includeReviewerProfile` | boolean | No | Include public reviewer profile URLs. Default `true`. |
| `includeOwnerResponses` | boolean | No | Include owner/management responses when visible. Default `true`. |
| `sortBy` | string | No | Optional Tripadvisor sort parameter appended to compatible URLs. |
| `language` | string | No | Optional locale hint for requests, e.g. `en-US`. |
| `requestTimeoutSecs` | integer | No | Per-request timeout in seconds. Default 30. |
| `useApifyProxy` | boolean | No | Route requests through Apify Proxy. Default `true`. |
| `proxyGroups` | array | No | Apify Proxy groups, e.g. `["RESIDENTIAL"]`. Empty = automatic pool. |

Example input:

```json
{
    "startUrls": [
        "https://www.tripadvisor.com/Restaurant_Review-g60763-d425787-Reviews-Katz_s_Delicatessen-New_York_City_New_York.html"
    ],
    "maxReviewsPerUrl": 100,
    "useApifyProxy": true,
    "proxyGroups": ["RESIDENTIAL"]
}
````

### ⬆️ Output example

Each review becomes one dataset item. This is real output from a run against the Katz's Delicatessen page:

```json
{
    "sourceUrl": "https://www.tripadvisor.com/Restaurant_Review-g60763-d425787-Reviews-Katz_s_Delicatessen-New_York_City_New_York.html",
    "listingName": "Katz's Deli",
    "listingType": "FoodEstablishment",
    "reviewId": "1067274741",
    "reviewTitle": "Go for the Pastrami - not for the social media post",
    "reviewText": "OK, the Pastrami Tour roles on to continue to introduce the kid to the classics. This time, right to The Source...",
    "rating": "5",
    "publishedDate": "July 6, 2026",
    "visitDate": "Jun 2026",
    "reviewerName": "herb v",
    "reviewerLocation": "West Amwell, New Jersey",
    "reviewerProfileUrl": "https://www.tripadvisor.com/Profile/mastiffdad",
    "helpfulVotes": "0",
    "rank": "1"
}
```

Other fields you may see per item: `listingUrl`, `reviewUrl`, `tripType`, `ownerResponseText`, `ownerResponseDate`, and `scrapedAt`. Fields that aren't publicly visible on a given review are simply omitted — the actor never fills gaps with invented values.

### 💰 How much does it cost to scrape Tripadvisor reviews?

The actor runs on pay-per-usage pricing, and because it uses lightweight HTTP requests instead of a headless browser, usage stays small. Measured on real runs:

- **1,000 reviews ≈ 0.37 compute units ≈ $0.15** in compute on the Apify Starter plan
- Residential proxy traffic adds roughly **0.011 GB per 1,000 reviews ≈ $0.09**
- **All-in: about $0.25 per 1,000 reviews** on the Starter plan

Very small runs cost slightly more per review because the first page of each listing is always fetched; larger runs come in a bit cheaper per 1,000. The Apify free plan's monthly credit is enough to scrape several thousand reviews at no cost, so you can test before committing to anything.

### 🏨 Need hotel prices and inventory, not reviews?

Pair this actor with [Booking.com Hotel Scraper](https://apify.com/automly/booking-scraper) — it extracts hotel names, nightly prices, guest ratings, and room types for a destination and dates. Together they give you both sides of the picture: what places charge and what guests say.

### ❓ FAQ

#### Do I need a proxy?

In practice, yes. Tripadvisor blocks most datacenter IP ranges outright. Keep **Use Apify Proxy** enabled and use the `RESIDENTIAL` proxy group for reliable results. The actor also recovers from blocks on its own: when a request returns HTTP 403 it rotates to a fresh proxy session with a different browser fingerprint and retries.

#### Which Tripadvisor URLs can I use?

Any public listing page: `Hotel_Review-...`, `Restaurant_Review-...`, or `Attraction_Review-...` URLs. Just copy the address from your browser while viewing the listing. Direct review-page URLs work too.

#### How many reviews can I scrape per run?

Up to 500 per start URL, and you can pass many URLs in a single run. Pagination is handled automatically. For larger ongoing collections, split listings across runs or set up a schedule.

#### What formats can I export?

The dataset can be downloaded as JSON, CSV, Excel, XML, or HTML from Apify Console, or fetched programmatically. The Overview table in the Output tab shows listing name, review title, rating, date, reviewer, and text at a glance.

#### Can I integrate it with other apps?

Yes. Through Apify integrations it connects to Google Sheets, Zapier, Make, Slack, LangChain, and more. Webhooks can notify your systems whenever a run finishes — the usual setup for reputation monitoring is a daily scheduled run plus a webhook into Slack.

#### Can I run it via API, MCP, or on a schedule?

Yes. Every actor on Apify is callable via a [REST API](https://docs.apify.com/api/v2), the official JavaScript and Python clients, or the CLI — see the **API** tab for ready-made code. AI agents can call it through the Apify MCP server. The built-in scheduler handles recurring runs (daily or weekly review monitoring).

#### Why did my run return zero reviews?

Almost always one of two things: the URL isn't a listing/review page (search results and forum pages aren't supported), or Tripadvisor served a block page to your proxy IP. The run log tells you which. Switching to the `RESIDENTIAL` proxy group fixes the second case in nearly every run we've seen.

#### Does it also scrape hotel prices or listing details?

No — this actor is focused on doing reviews well. Basic listing context (name, type, URL) is attached to every review so you can join the data with other sources. For prices and inventory, use [Booking.com Hotel Scraper](https://apify.com/automly/booking-scraper).

### 🔗 Related actors

- [Booking.com Hotel Scraper](https://apify.com/automly/booking-scraper) — extract hotel names, nightly prices, guest ratings, and room types from Booking.com
- [Google Maps Scraper](https://apify.com/automly/google-maps-scraper) — extract places, ratings, and contact details from Google Maps
- [Airbnb Listings Scraper](https://apify.com/automly/airbnb-listings-scraper) — scrape Airbnb listings, prices, and availability
- [Facebook Ad Library Scraper](https://apify.com/automly/facebook-ad-library-scraper) — pull competitor ads from Meta's Ad Library

Questions or a page variant that doesn't parse? Open an issue on the actor page and include the URL — markup changes get fixed quickly.

# Actor input Schema

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

Tripadvisor listing or review page URLs to scrape.

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

Maximum number of reviews to save for each start URL.

## `includeReviewerProfile` (type: `boolean`):

Include reviewer profile URLs when publicly visible.

## `includeOwnerResponses` (type: `boolean`):

Include management/owner responses when publicly visible.

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

Optional Tripadvisor sort parameter value to append when compatible.

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

Optional language or locale hint to request, such as en-US.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## `useApifyProxy` (type: `boolean`):

Route requests through Apify Proxy in Apify cloud runs.

## `proxyGroups` (type: `array`):

Optional Apify Proxy groups. Leave empty for automatic/default proxy pool.

## Actor input object example

```json
{
  "maxReviewsPerUrl": 50,
  "includeReviewerProfile": true,
  "includeOwnerResponses": true,
  "requestTimeoutSecs": 30,
  "useApifyProxy": true
}
```

# Actor output Schema

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

One row per review: listing, title, rating, date, reviewer, and text.

## `fullData` (type: `string`):

All fields including reviewer profile, owner responses, and listing context.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("automly/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("automly/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 '{}' |
apify call automly/tripadvisor-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tripadvisor Reviews Scraper",
        "description": "Extract Tripadvisor reviews from hotel, restaurant, and attraction pages: ratings, full review text, dates, reviewer profiles, and owner responses. Paste listing URLs, set a limit, and export to JSON, CSV, or Excel. Useful for sentiment analysis, market research, and reputation monitoring.",
        "version": "1.0",
        "x-build-id": "xwLx47ckb6c5Neejd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automly~tripadvisor-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automly-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/automly~tripadvisor-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automly-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/automly~tripadvisor-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automly-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": "Start URLs",
                        "type": "array",
                        "description": "Tripadvisor listing or review page URLs to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerUrl": {
                        "title": "Maximum reviews per URL",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to save for each start URL.",
                        "default": 50
                    },
                    "includeReviewerProfile": {
                        "title": "Include reviewer profile",
                        "type": "boolean",
                        "description": "Include reviewer profile URLs when publicly visible.",
                        "default": true
                    },
                    "includeOwnerResponses": {
                        "title": "Include owner responses",
                        "type": "boolean",
                        "description": "Include management/owner responses when publicly visible.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "type": "string",
                        "description": "Optional Tripadvisor sort parameter value to append when compatible."
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Optional language or locale hint to request, such as en-US."
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 30
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify Proxy in Apify cloud runs.",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Proxy groups",
                        "type": "array",
                        "description": "Optional Apify Proxy groups. Leave empty for automatic/default proxy pool.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
