# Tripadvisor Email Scraper (`scraperx/tripadvisor-email-scraper`) Actor

📧 Tripadvisor Email Scraper helps you extract verified review-related email data from TripAdvisor listings quickly. Efficient for lead generation, market research & outreach. 🚀 Easy setup, reliable results. ✅ Great for B2B teams.

- **URL**: https://apify.com/scraperx/tripadvisor-email-scraper.md
- **Developed by:** [ScraperX](https://apify.com/scraperx) (community)
- **Categories:** Lead generation, Travel, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### **Tripadvisor** Email Scraper 📱

**Tripadvisor** Email Scraper allows users to **extract** a variety of **data** from **Tripadvisor** profiles and reviews. It provides access to email addresses, user names, review content, ratings, and other relevant details.

This tool is ideal for businesses seeking to **extract** **emails** from **Tripadvisor** for marketing or outreach purposes. It also supports **Tripadvisor** **data** **extract**ion for analyzing customer feedback and trends.

The scraper can identify and collect **contact** details from **Tripadvisor** profiles efficiently. It is a comprehensive solution for scraping **Tripadvisor** reviews and gathering structured **data**.

With its automated features, the scraper simplifies the process of retrieving essential information from **Tripadvisor**.

Tripadvisor Email Scraper is an advanced tool designed for extracting email addresses and other valuable data from Tripadvisor profiles and reviews. It helps businesses and developers streamline lead generation and data collection processes efficiently.

With the ability to scrape Tripadvisor reviews and contact information, this scraper offers a powerful solution for accessing essential data for marketing, analysis, and outreach. It is ideal for businesses looking to expand their customer base or analyze user feedback.

Tripadvisor Email Scraper automates the process of extracting emails from Tripadvisor, saving time and effort compared to manual methods. It ensures accuracy and reliability in gathering data from one of the most popular travel platforms.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract email addresses from Tripadvisor profiles and reviews. |
| User names | Retrieve names of users associated with Tripadvisor accounts. |
| Review content | Scrape detailed review text from Tripadvisor listings. |
| Ratings | Collect star ratings and other feedback metrics from reviews. |
| Profile information | Access public profile details of Tripadvisor users. |
| Location data | Extract location information associated with reviews and profiles. |
| Business contact details | Gather contact information from business listings on Tripadvisor. |
| Review dates | Retrieve timestamps of reviews for trend analysis. |

### Key Features of **Tripadvisor** Email Scraper

Here are the **standout features** that make the **Tripadvisor** Email Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ **Automated** extraction of emails from **Tripadvisor** profiles and reviews
- ⭐ Supports scraping **Tripadvisor** reviews for detailed feedback analysis
- ⭐ **Accurate** and reliable data collection for lead generation purposes
- ⭐ Ability to extract multiple data types including ratings and user names
- ⭐ User-friendly interface for easy configuration and data retrieval
- ⭐ Handles large-scale data extraction with high efficiency
- ⭐ Provides structured data output for seamless integration with other tools
- ⭐ **Customizable** scraping options to target specific profiles or reviews
- ⭐ Ensures compliance with legal and ethical guidelines for data scraping
- ⭐ Compatible with various platforms and systems for versatile usage
- ⭐ Offers detailed documentation and support for troubleshooting
- ⭐ **Regular** updates to maintain compatibility with **Tripadvisor**s platform

### How to use **Tripadvisor** Email Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Tripadvisor** emails today:

1. ✅ **Sign up** for an Apify account to access the **Tripadvisor** Email Scraper
2. ✅ Navigate to the scrapers page in the Apify library and click Try for free
3. ✅ **Configure** the scraper settings by entering the target URLs or keywords
4. ✅ **Select** the specific data types you want to extract such as emails or reviews
5. ✅ Adjust advanced settings for customized scraping preferences if needed
6. ✅ **Start** the scraper and monitor the progress in the Apify dashboard
7. ✅ Download the extracted data in your preferred format once the process is complete
8. ✅ Use the data for analysis outreach or integration with other tools

### Use Cases 🎯

Lead Generation
🎯 Extract emails from **Tripadvisor** profiles for targeted marketing campaigns
🎯 **Automate** the process of collecting contact details for outreach

Customer Feedback Analysis
🎯 Scrape **Tripadvisor** reviews to analyze customer opinions and trends
🎯 Gather ratings and review content for product or service improvement

Business Intelligence
🎯 Extract structured data from **Tripadvisor** for market research
🎯 **Use** location and profile data to identify key demographics

Travel Industry Insights
🎯 **Analyze** **Tripadvisor** data to understand traveler preferences
🎯 Gather business contact details for partnerships or collaborations

### Why choose us? 💎

**Tripadvisor** Email Scraper is the **best** **Tripadvisor** scraping software for businesses and developers seeking **reliable** data extraction solutions. Our tool is designed to automate the process of scraping **Tripadvisor** reviews and extracting emails, saving time and resources.

We offer customizable options to target specific data types, ensuring you get the information you need. With our scraper, you can perform **Tripadvisor** data extraction efficiently and accurately.

We prioritize user experience by providing a **user-friendly** interface and detailed documentation. Our scraper supports large-scale data collection, making it suitable for businesses of all sizes.

We ensure compliance with legal and ethical guidelines, giving you peace of mind while using our tool. Regular updates keep our scraper compatible with **Tripadvisor**'s platform, ensuring uninterrupted performance.

Choose **Tripadvisor** Email Scraper for a **reliable**, efficient, and compliant solution to your data extraction needs.

### **Tripadvisor** Email Scraper Scalability 📈

**Tripadvisor** Email Scraper is built to handle data extraction at scale, making it ideal for businesses with large data needs. It supports automated **Tripadvisor** email scraping, allowing you to collect vast amounts of information quickly.

Whether you need to scrape **Tripadvisor** reviews or extract emails from multiple profiles, our tool can manage the workload **efficient**ly. It is designed to perform high-volume data extraction without compromising accuracy or reliability.

With **customizable** settings, you can tailor the scraper to meet your specific requirements. Our scraper ensures consistent performance, even when handling complex or **extensive** data sets.

Choose **Tripadvisor** Email Scraper for scalable and **efficient** data extraction solutions.

### **Tripadvisor** Email Scraper Legal Guidelines ⚖️

**Yes**—scraping **Tripadvisor** is **legal** as long as you follow **ethical** and **compliant** practices. The **Tripadvisor** Email Scraper extracts only **publicly available** information from **public** **Tripadvisor** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Tripadvisor**s terms of service when using the scraper
⚖️ **Avoid** scraping private or sensitive information from **Tripadvisor** profiles
⚖️ **Use** the scraper for legitimate purposes such as lead generation or analysis
⚖️ **Do not** use the extracted data for spamming or unethical marketing practices
⚖️ Respect user privacy and avoid unauthorized access to restricted data
⚖️ **Adhere** to local and international data protection laws when using the scraper
⚖️ **Ensure** proper attribution when using data extracted from **Tripadvisor**
⚖️ Consult legal professionals if unsure about the legality of your scraping activities

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Tripadvisor Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Tripadvisor",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails to collect (default 20) |
| platform | Platform to scrape (Tripadvisor) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Tripadvisor",
    "keyword": "Tripadvisor Email Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "email": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Tripadvisor as the source |
| keyword | Keyword that triggered the result (Tripadvisor Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Tripadvisor profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Tripadvisor **Email Scraper**?

Tripadvisor Email Scraper is a tool designed to extract **emails** and other data from Tripadvisor profiles and reviews.

#### Can I use this scraper for **lead generation**?

**Yes**, the scraper is ideal for extracting **emails** from Tripadvisor for targeted marketing and outreach.

#### What data types can I **extract** with this tool?

You can extract **emails**, user names, review content, ratings, profile information, and more.

#### Is the scraper compliant with **legal** guidelines?

**Yes**, the scraper is designed to comply with legal and ethical guidelines for data scraping.

#### How do I configure the scraper settings?

You can configure settings by entering target URLs, selecting data types, and adjusting advanced options.

#### Can I scrape Tripadvisor reviews with this tool?

**Yes**, the scraper supports extracting detailed review content and ratings from Tripadvisor.

#### Does the scraper handle **large-scale** data **extract**ion?

**Yes**, it is designed to manage high-volume data collection efficiently.

#### What output formats are supported?

You can download extracted data in formats such as **JSON**, **CSV**, or Excel.

#### Is technical support available for this scraper?

**Yes**, we provide detailed documentation and support for troubleshooting.

#### Can I customize the scraping process?

**Yes**, the scraper offers customizable settings to target specific profiles or data types.

#### How often is the scraper updated?

The scraper is regularly updated to maintain compatibility with Tripadvisor's platform.

#### Is the scraper suitable for small businesses?

**Yes**, it is designed for **businesses** of all sizes, including small and medium enterprises.

#### Can I use the scraper for market research?

**Yes**, the scraper is ideal for extracting data for market analysis and research.

#### Are there any restrictions on data usage?

You must comply with legal guidelines and avoid using data for unethical purposes.

#### How long does data **extract**ion take?

The time depends on the volume of data and scraper settings, but it is optimized for efficiency.

# Actor input Schema

## `keywords` (type: `array`):

List of keywords to search for on Tripadvisor (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Tripadvisor profiles/posts containing these keywords and extract email addresses.

## `platform` (type: `string`):

Select platform.

## `location` (type: `string`):

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

## `maxEmails` (type: `integer`):

Maximum number of emails to collect per keyword (default: 20).

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Tripadvisor",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperx/tripadvisor-email-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 = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperx/tripadvisor-email-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 '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraperx/tripadvisor-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tripadvisor Email Scraper",
        "description": "📧 Tripadvisor Email Scraper helps you extract verified review-related email data from TripAdvisor listings quickly. Efficient for lead generation, market research & outreach. 🚀 Easy setup, reliable results. ✅ Great for B2B teams.",
        "version": "0.1",
        "x-build-id": "h27xcKV3ZU5f0Bq1z"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~tripadvisor-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-tripadvisor-email-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/scraperx~tripadvisor-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-tripadvisor-email-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/scraperx~tripadvisor-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-tripadvisor-email-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Tripadvisor (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Tripadvisor profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Tripadvisor"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Tripadvisor"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```