# Hotels Com Email Scraper (`scrapapi/hotels-com-email-scraper`) Actor

📧 Hotels Com Email Scraper extracts verified hotel email addresses from Hotels.com listings. Automate lead generation, outreach, and market research with clean data. ✅ Perfect for B2B sales, PR, and partnerships. 🚀 Try hotels-com-email-scraper today!

- **URL**: https://apify.com/scrapapi/hotels-com-email-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Lead generation, Travel, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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

### **Hotels.com** Email Scraper 📱

Hotels Com Email Scraper allows users to **extract** a wide range of **data** from **Hotels. com** listings.

This includes essential **contact** information, such as email addresses, phone numbers, and website links. It also captures hotel details like names, locations, and ratings to provide a comprehensive **data**set.

The tool is designed to ensure accuracy and relevance, making it a reliable resource for businesses in the hospitality industry. Users can customize their scraping parameters to focus on specific regions, hotel categories, or other criteria.

This flexibility ensures that the **extract**ed **data** aligns with your unique business objectives. Whether you need to **extract** hotel **emails** online or gather **data** for marketing campaigns, Hotels Com Email Scraper simplifies the process with its user-friendly interface and advanced features.

Hotels Com Email Scraper is a powerful tool designed to extract email addresses and contact information from Hotels. com efficiently.

It helps businesses in the hospitality industry streamline their outreach and marketing efforts.

With Hotels Com Email Scraper, you can gather valuable data from hotel listings, including contact emails, to build targeted email campaigns. This tool is ideal for businesses looking to connect with hotels for partnerships, promotions, or services.

Hotels. com is a leading platform for hotel bookings, making it a rich source of contact information for hospitality professionals.

Our scraper ensures accurate and reliable data extraction tailored to your business needs.

### 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 |
| --- | --- |
| Hotel Name | Extracts the name of the hotel as listed on Hotels.com. |
| Email Address | Captures the contact email address associated with the hotel. |
| Phone Number | Retrieves the phone number provided for the hotel. |
| Website URL | Extracts the official website link of the hotel, if available. |
| Location | Gathers the hotel's address, including city and country details. |
| Ratings | Captures user ratings and reviews for the hotel. |
| Price Range | Extracts pricing details for rooms or services offered by the hotel. |
| Amenities | Lists key amenities and facilities provided by the hotel. |

### Key Features of **Hotels.com** Email Scraper

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

- ⭐ **Automated** scraping of hotel email addresses and contact details from Hotelscom
- ⭐ **Customizable** filters to target specific regions hotel categories or price ranges
- ⭐ **Accurate** data extraction with minimal errors or duplicates
- ⭐ User-friendly interface for easy setup and operation without technical expertise
- ⭐ Support for large-scale data scraping to handle extensive datasets efficiently
- ⭐ Compliance with legal and ethical guidelines for responsible data extraction
- ⭐ Export data in multiple formats including CSV and JSON for easy integration
- ⭐ **Regular** updates to ensure compatibility with Hotelscom website changes
- ⭐ **Advanced** scheduling options for automated and recurring scraping tasks
- ⭐ Detailed logs and reports for tracking scraping activities and results
- ⭐ **Secure** and encrypted data handling to protect sensitive information
- ⭐ 247 customer support to assist with any issues or queries

### How to use **Hotels.com** Email Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Hotels.com** emails today:

1. ✅ **Sign up** or **log in** to the Hotels Com Email Scraper platform
2. ✅ Navigate to the dashboard and select New Scraping Task
3. ✅ Enter the URL of the Hotelscom page you wish to scrape
4. ✅ Set your scraping parameters such as location hotel category or price range
5. ✅ Choose the data types you want to extract such as email addresses or phone numbers
6. ✅ **Configure** the output format for your data such as CSV or JSON
7. ✅ Click **Start** Scraping to initiate the data extraction process
8. ✅ Monitor the progress of your task through the dashboard
9. ✅ Once completed download your extracted data from the results section
10. ✅ **Review** the data and use it for your marketing or outreach campaigns
11. ✅ Schedule recurring tasks if you need regular updates from Hotelscom
12. ✅ Contact customer support if you encounter any issues during the process

### Use Cases 🎯

Marketing Campaigns
🎯 Build targeted email lists for hotel promotions and services
🎯 Reach out to hotels for collaboration opportunities

Business Development
🎯 **Identify** potential hotel partners for your business
🎯 Gather contact information for networking and outreach

Market Research
🎯 **Analyze** hotel pricing and amenities across different regions
🎯 **Study** customer ratings and reviews for competitive analysis

Lead Generation
🎯 Generate high-quality leads for hospitality-related services
🎯 Create a comprehensive database of hotel contacts

### Why choose us? 💎

Hotels Com Email Scraper is a **reliable** and efficient tool for extracting hotel contact information from **Hotels. com**.

It is designed to meet the needs of businesses in the hospitality industry by providing accurate and comprehensive data. Our tool automates the data extraction process, saving you time and effort while delivering high-quality results.

With customizable filters and **advanced** features, you can tailor the scraping process to your specific requirements. Whether you need to extract hotel emails online or gather data for marketing campaigns, our scraper offers a seamless and **user-friendly** experience.

We prioritize compliance with legal and ethical guidelines, ensuring that your data collection activities are responsible and secure. Our platform is **regular**ly updated to stay compatible with **Hotels.

com**, so you can rely on it for consistent performance. Choose Hotels Com Email Scraper for a powerful and **scalable** solution to your data extraction needs.

### **Hotels.com** Email Scraper Scalability 📈

Hotels Com Email Scraper is built to handle data extraction tasks of any size, making it suitable for businesses of all scales. Whether you need to gather information from a few hotel listings or thousands, our tool can manage the workload **efficient**ly.

With **advanced** scheduling and automation features, you can set up recurring tasks to keep your data up-to-date without manual intervention. The scraper is optimized for speed and accuracy, ensuring that you receive reliable results even for large datasets.

Our platform also supports multiple output formats, allowing you to integrate the extracted data **seamless**ly into your existing systems. As your business grows, Hotels Com Email Scraper can scale with you, providing the flexibility and performance you need to succeed in the competitive hospitality industry.

### **Hotels.com** Email Scraper Legal Guidelines ⚖️

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with Hotelscoms terms of service when using the scraper
⚖️ **Do not** use the scraper to collect personal information without consent
⚖️ **Avoid** spamming or unsolicited contact using the extracted data
⚖️ **Use** the tool for legitimate business purposes only
⚖️ Respect data privacy laws and regulations in your region
⚖️ **Do not** resell or distribute the extracted data without proper authorization
⚖️ Monitor for updates to Hotelscoms policies and adjust usage accordingly
⚖️ Consult legal counsel if you are unsure about the legality of your scraping activities

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Hotels Com Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Hotels.com",
  "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 (Hotels.com) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Hotels.com",
    "keyword": "Hotels Com 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 Hotels.com as the source |
| keyword | Keyword that triggered the result (Hotels Com Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Hotels.com profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Hotels Com **Email Scraper**?

Hotels Com Email Scraper is a tool designed to extract email addresses and contact information from Hotels.com efficiently.

#### Is the scraper easy to use?

**Yes**, the scraper features a **user-friendly** interface that does not require technical expertise.

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

You can extract hotel names, email addresses, phone numbers, website URLs, locations, ratings, price ranges, and amenities.

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

**Yes**, the scraper is designed to comply with legal and ethical data collection standards.

#### Can I customize the scraping parameters?

**Yes**, you can set filters for location, hotel category, price range, and more.

#### What output formats are supported?

The tool supports **CSV** and **JSON** formats for exporting data.

#### How often is the scraper updated?

The scraper is regularly updated to ensure compatibility with Hotels.com.

#### Can I schedule recurring scraping tasks?

**Yes**, the tool allows you to automate and schedule recurring data extraction tasks.

#### Is **customer support** available?

**Yes**, we provide 24/7 customer support to assist with any issues.

#### Can I use the scraper for **large-scale** data **extract**ion?

**Yes**, the scraper is built to handle large datasets efficiently.

#### Is my data **secure** with this tool?

**Yes**, the scraper uses **secure** and encrypted data handling processes.

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

**Yes**, the tool is ideal for analyzing hotel pricing, amenities, and customer reviews.

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

The scraper is a cloud-based tool and can be accessed from any device with an internet connection.

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

**Yes**, the tool is perfect for generating high-quality leads in the hospitality industry.

#### Is there a free trial available?

**Yes**, we offer a free trial so you can explore the tool's features before purchasing.

# Actor input Schema

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

List of keywords to search for on Hotels (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Hotels 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": "Hotels",
  "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/hotels-com-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/hotels-com-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/hotels-com-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hotels Com Email Scraper",
        "description": "📧 Hotels Com Email Scraper extracts verified hotel email addresses from Hotels.com listings. Automate lead generation, outreach, and market research with clean data. ✅ Perfect for B2B sales, PR, and partnerships. 🚀 Try hotels-com-email-scraper today!",
        "version": "0.1",
        "x-build-id": "PL27QtwP248tjZ5JS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~hotels-com-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-hotels-com-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~hotels-com-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-hotels-com-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~hotels-com-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-hotels-com-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 Hotels (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Hotels profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Hotels"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Hotels"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```