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

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

## Pricing

from $2.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** structured **data** from **Tripadvisor** listings. The tool focuses on retrieving **contact** information such as email addresses, phone numbers, and other relevant details.

Extracting **Tripadvisor** **data** is essential for businesses aiming to build targeted marketing campaigns or analyze customer information. This scraper tool ensures that users can access clean and organized **data** for further use.

By automating the **data** **extract**ion process, users can save time and focus on strategic tasks. The **extract**ed **data** is ideal for lead generation, customer outreach, and competitive analysis.

Tripadvisor Email Scraper is a powerful tool designed to extract contact information from Tripadvisor efficiently. This tool helps businesses and marketers gather valuable leads from Tripadvisor listings.

Scraping Tripadvisor data enables users to access essential contact details for hotels, restaurants, and attractions. With the right email scraping tools, you can automate data extraction and save time.

Tripadvisor Email Scraper simplifies the process of gathering email addresses for outreach and marketing purposes. It is an ideal solution for those seeking to extract emails from Tripadvisor listings effortlessly.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract verified email addresses from Tripadvisor listings for outreach. |
| Phone numbers | Retrieve contact phone numbers from business profiles on Tripadvisor. |
| Business names | Collect names of hotels, restaurants, and attractions listed on Tripadvisor. |
| Website URLs | Extract official website links provided in Tripadvisor profiles. |
| Location details | Gather detailed location data including addresses and cities. |
| Ratings and reviews | Scrape ratings and reviews from Tripadvisor listings for analysis. |
| Categories | Identify business categories such as hotels, restaurants, or attractions. |
| Operating hours | Extract business hours listed on Tripadvisor profiles. |

### 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** data extraction from **Tripadvisor** listings for seamless lead generation
- ⭐ Retrieve accurate email addresses and contact details from verified profiles
- ⭐ Supports scraping multiple types of data including phone numbers and website URLs
- ⭐ User-friendly interface designed for both beginners and advanced users
- ⭐ **Customizable** scraping options to target specific categories or locations
- ⭐ Ensures clean and structured data output for easy integration into workflows
- ⭐ **High**-speed scraping capabilities for large-scale data extraction projects
- ⭐ **Regular** updates to ensure compatibility with **Tripadvisor**s platform changes
- ⭐ **Secure** and compliant data extraction methods to protect user privacy
- ⭐ Export data in multiple formats such as CSV or JSON for convenience

### 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 tool
2. ✅ Navigate to the scraper tool page and click on **Start** Actor
3. ✅ Enter the desired search parameters such as location or business category
4. ✅ Specify the type of data you want to extract including email addresses or phone numbers
5. ✅ **Configure** additional settings like the number of listings to scrape or output format
6. ✅ Click Run to initiate the scraping process and monitor progress in real-time
7. ✅ Download the extracted data once the scraping process is complete
8. ✅ **Integrate** the data into your CRM or marketing tools for further use

### Use Cases 🎯

Lead Generation
🎯 Extract email addresses from **Tripadvisor** listings for direct outreach
🎯 Build targeted campaigns using verified contact information

Market Research
🎯 **Analyze** **Tripadvisor** data to identify trends in customer reviews and ratings
🎯 Understand competitor strategies by studying their profiles

Business Expansion
🎯 **Find** potential partners or suppliers by scraping contact details from **Tripadvisor**
🎯 **Identify** new markets by analyzing location-based data

Customer Engagement
🎯 **Use** scraped email addresses to send personalized offers and updates
🎯 Enhance customer service by accessing detailed contact information

### Why choose us? 💎

**Tripadvisor** Email Scraper is the ultimate solution for extracting valuable data from **Tripadvisor** efficiently. Our tool is designed to meet the needs of businesses, marketers, and researchers seeking accurate and **reliable** contact information.

By using our **Tripadvisor** scraper tool, you can automate the process of gathering essential data, saving time and resources. We prioritize user experience by offering a simple yet powerful interface that caters to both beginners and **advanced** users.

Our scraper ensures compliance with legal guidelines, providing secure and ethical data extraction methods. With **regular** updates, we guarantee compatibility with **Tripadvisor**'s platform changes, ensuring uninterrupted service.

Whether you're looking to scrape **Tripadvisor** emails or extract other data types, our tool delivers high-speed performance and structured outputs. Choose **Tripadvisor** Email Scraper to unlock the potential of **Tripadvisor** data for lead generation, market research, and business growth.

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

**Tripadvisor** Email Scraper is designed to handle data extraction projects of all sizes. Whether you need to scrape a few listings or thousands of profiles, our tool ensures consistent performance.

The scraper supports high-speed data extraction, making it ideal for **large-scale** lead generation campaigns. By automating the process, users can focus on strategic tasks while the tool handles data collection.

Our scraper is optimized to work with complex datasets, ensuring clean and structured outputs for further use. With **customizable** settings, users can tailor the scraping process to meet specific needs, such as targeting particular categories or locations.

Choose **Tripadvisor** Email Scraper for scalable and reliable data extraction solutions that grow with your business.

### **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
⚖️ **Do not** use the extracted data for spamming or unethical marketing practices
⚖️ Always obtain necessary permissions before contacting businesses or individuals
⚖️ **Use** the scraper responsibly to avoid overloading **Tripadvisor**s servers
⚖️ Respect privacy laws and regulations when handling scraped data
⚖️ **Do not** redistribute or sell extracted data without proper authorization
⚖️ Maintain transparency in your data usage to build trust with your audience
⚖️ Regularly review legal guidelines to ensure ethical data extraction practices

### 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 contact information and other data from Tripadvisor listings efficiently.

#### What data can I **extract** using this tool?

You can extract email addresses, phone numbers, business names, website URLs, location details, ratings, reviews, categories, and operating hours.

#### Is the scraper easy to use?

**Yes**, Tripadvisor Email Scraper features a **user-friendly** interface suitable for both beginners and advanced users.

#### Can I customize the scraping process?

**Yes**, you can configure settings such as search parameters, data types, and output formats to tailor the scraping process.

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

**Yes**, our scraper ensures **secure** and ethical data extraction methods in **compliance** with privacy laws and regulations.

#### How fast is the data **extract**ion process?

The scraper supports high-speed data extraction, making it ideal for large-scale projects.

#### What output formats are available?

You can export the extracted data in formats such as **CSV** or **JSON** for easy integration into workflows.

#### Can I scrape data from **specific** locations?

**Yes**, you can target specific locations by entering relevant search parameters during setup.

#### Is the scraper regularly updated?

**Yes**, we provide **regular updates** to ensure compatibility with Tripadvisor's platform changes.

#### Can I use the data for marketing purposes?

**Yes**, you can use the extracted data for ethical marketing campaigns and lead generation.

#### Does the tool support **large-scale** data **extract**ion?

**Yes**, Tripadvisor Email Scraper is designed to handle projects of all sizes efficiently.

#### Is technical support available?

**Yes**, we offer technical support to assist users with any issues or questions.

#### Can I scrape ratings and reviews?

**Yes**, the tool allows you to extract ratings and reviews from Tripadvisor listings for analysis.

#### What are the system requirements for using the scraper?

The scraper runs on Apify's platform, which requires an internet connection and a web browser.

#### Is the tool **secure**?

**Yes**, Tripadvisor Email Scraper uses **secure** methods to protect user data and ensure ethical practices.

# 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("scrapapi/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("scrapapi/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 scrapapi/tripadvisor-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tripadvisor Email Scraper",
        "version": "0.1",
        "x-build-id": "0AlMigEmr2owbpky5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~tripadvisor-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-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/scrapapi~tripadvisor-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-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/scrapapi~tripadvisor-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```