# Kayak Email Scraper (`scraper-engine/kayak-email-scraper`) Actor

Kayak Email Scraper extracts publicly available airline, hotel, and travel provider email addresses from Kayak listings. Build targeted contact lists by route or destination. Ideal for travel marketers and agencies.

- **URL**: https://apify.com/scraper-engine/kayak-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (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

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

### **Social Media** Email Scraper 📱

Kayak Email Scraper allows users to **extract** a variety of **data** types from Kayak, focusing on email information and related details. This tool is designed to provide structured and organized **data** for businesses and individuals looking to optimize their outreach or research efforts.

Users can **extract** email addresses of customers, travel agents, and other relevant **contact**s directly from Kayak's platform. Additionally, it can retrieve supplementary **data** such as names, travel preferences, and booking details to enhance the usability of the **extract**ed information.

The scraper ensures high accuracy and reliability in **data** collection, making it a valuable asset for lead generation and market analysis. By automating the **extract**ion process, Kayak Email Scraper minimizes manual work and maximizes efficiency, helping users achieve their goals faster and more effectively.

Kayak Email Scraper is a powerful tool designed to help users extract valuable email data from Kayak, one of the leading travel booking platforms. It enables efficient data collection for businesses and individuals seeking leads or insights from travel-related sources.

With Kayak Email Scraper, users can automate the process of gathering email information, saving time and reducing manual effort. This tool is ideal for lead generation, customer outreach, and market research in the travel industry.

Kayak Email Scraper leverages advanced technology to ensure accurate and comprehensive data extraction. It is designed to handle large-scale data scraping while maintaining compliance with legal and ethical guidelines.

### 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 of customers, travel agents, and other relevant contacts from Kayak. |
| Names | Retrieve names associated with the email addresses for personalized outreach. |
| Travel preferences | Collect data on preferred destinations and travel types for targeted marketing. |
| Booking details | Extract information on recent bookings made through Kayak for lead qualification. |
| Contact information | Gather additional contact details such as phone numbers if available. |
| Customer reviews | Scrape reviews and feedback to understand customer sentiment and preferences. |
| Location data | Retrieve location-based data for geographical analysis and segmentation. |
| Travel agent profiles | Extract profiles and contact details of travel agents listed on Kayak. |

### Key Features of **Social Media** Email Scraper

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

- ⭐ **Automated** email extraction from Kayak for efficient data collection
- ⭐ **Customizable** scraping parameters to tailor data extraction to specific needs
- ⭐ **High** accuracy and reliability in extracting structured email data
- ⭐ Capability to extract supplementary information such as names and booking details
- ⭐ User-friendly interface for seamless operation and minimal learning curve
- ⭐ Compliance with legal and ethical guidelines for responsible data scraping
- ⭐ Scalable solution designed to handle large volumes of data efficiently
- ⭐ **Integration** options with CRM tools for streamlined lead management
- ⭐ **Regular** updates to ensure compatibility with Kayaks platform changes
- ⭐ **Advanced** filtering options to refine extracted data based on user preferences
- ⭐ **Secure** data handling to protect sensitive information during extraction
- ⭐ Detailed documentation and support for troubleshooting and optimization

### How to use **Social Media** Email Scraper 🚀

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

1. ✅ **Sign up** for the Kayak Email Scraper tool on the official platform
2. ✅ Install the scraper software or access it via the web interface
3. ✅ Log in to your account using your credentials to access the tool
4. ✅ Set up your scraping parameters including target data types and filters
5. ✅ Enter the URL or section of Kayak you wish to scrape for email data
6. ✅ Run the scraper and monitor the progress through the dashboard
7. ✅ Download the extracted data in your preferred format once the process is complete
8. ✅ **Integrate** the data with your CRM or analysis tools for further use
9. ✅ **Review** and refine your scraping settings for future extractions as needed
10. ✅ Ensure compliance with Kayaks terms of service and legal guidelines

### Use Cases 🎯

Lead Generation
🎯 Extract emails from Kayak to build a database of potential leads
🎯 **Use** Kayak lead generation tool to identify travel agents and customers for outreach

Market Research
🎯 **Analyze** travel preferences and booking trends using extracted data
🎯 Understand customer sentiment by scraping reviews and feedback

Email Marketing
🎯 Create targeted email campaigns using data from Kayak
🎯 Leverage Kayak email automation to streamline communication with prospects

Business Insights
🎯 **Identify** key travel destinations and customer demographics
🎯 **Use** extracted data to optimize travel-related services and offerings

### Why choose us? 💎

Kayak Email Scraper is a **reliable** and efficient tool for extracting valuable email data from Kayak and other travel platforms. It is designed to simplify the data collection process, enabling businesses to focus on utilizing insights for growth.

Our tool offers high accuracy and customizable features, ensuring users can tailor their scraping needs to specific goals. With **advanced** filtering options and integration capabilities, Kayak Email Scraper supports seamless lead management and market analysis.

We prioritize compliance with legal and ethical guidelines, providing users with a trustworthy solution for data extraction. Whether you need a travel site email scraper for lead generation or market research, our tool is built to handle diverse requirements.

Choose Kayak Email Scraper for its **user-friendly** interface, scalability, and secure data handling, making it the ideal choice for travel-related data extraction.

### **Social Media** Email Scraper Scalability 📈

Kayak Email Scraper is designed to handle **large-scale** data extraction **efficient**ly, making it suitable for businesses of all sizes. Whether you need to scrape emails from Kayak for a small project or a large campaign, our tool adapts to your needs.

It supports high-volume data processing without compromising accuracy or reliability, ensuring consistent results even for **extensive** scraping tasks. The tool's **customizable** features allow users to refine their parameters for targeted data collection, optimizing performance for specific requirements.

With regular updates and robust infrastructure, Kayak Email Scraper remains compatible with platform changes and ensures smooth operation. Its scalability makes it an ideal solution for growing businesses seeking to expand their outreach and data analysis capabilities.

### **Social Media** Email Scraper Legal Guidelines ⚖️

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with Kayaks terms of service before using the scraper
⚖️ **Use** the tool only for lawful purposes and avoid unauthorized data collection
⚖️ **Do not** misuse extracted data for spamming or unethical practices
⚖️ Respect user privacy and avoid scraping sensitive personal information
⚖️ Follow local and international data protection regulations during scraping
⚖️ **Obtain** necessary permissions if required for specific data extraction tasks
⚖️ **Use** Kayak Email Scraper responsibly and ethically in line with industry standards
⚖️ Regularly review legal guidelines to stay updated on compliance requirements

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is Kayak **Email Scraper**?

Kayak Email Scraper is a tool designed to extract email data and related information from Kayak for lead generation and research purposes.

#### How does Kayak **Email Scraper** work?

It automates the process of collecting email addresses and supplementary data from Kayak using advanced scraping technology.

#### Is Kayak **Email Scraper** **legal** to use?

**Yes**, it is legal when used in **compliance** with Kayak's terms of service and applicable data protection regulations.

#### What data can I **extract** using Kayak **Email Scraper**?

You can extract email addresses, names, travel preferences, booking details, and other related information from Kayak.

#### Can I customize the scraping parameters?

**Yes**, the tool allows users to set specific filters and parameters for targeted data extraction.

#### Is Kayak **Email Scraper** suitable for **large-scale** data **extract**ion?

**Yes**, it is designed to handle high volumes of data efficiently, making it suitable for **businesses** of all sizes.

#### Does Kayak **Email Scraper** integrate with **CRM** tools?

**Yes**, the tool supports integration with CRM platforms for streamlined lead management.

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

The tool ensures **secure** data handling and protects sensitive information during scraping.

#### What formats can I download the **extract**ed data in?

You can download the data in various formats, including **CSV** and Excel, for easy analysis and integration.

#### Do I need technical expertise to use Kayak **Email Scraper**?

**No**, the tool is **user-friendly** and designed for users with minimal technical knowledge.

#### Can I use Kayak **Email Scraper** for other travel websites?

While it is optimized for Kayak, the tool may support scraping from other travel platforms depending on compatibility.

#### What are the system requirements for Kayak **Email Scraper**?

The tool can be accessed via a web interface or installed on systems meeting basic software requirements.

#### Is there **customer support** available for Kayak **Email Scraper**?

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

#### How often is Kayak **Email Scraper** updated?

The tool is regularly updated to ensure compatibility with Kayak's platform changes and improve functionality.

#### Can I try Kayak **Email Scraper** before purchasing?

**Yes**, a trial version may be available to help users evaluate the tool's features and performance.

# Actor input Schema

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kayak Email Scraper",
        "description": "Kayak Email Scraper extracts publicly available airline, hotel, and travel provider email addresses from Kayak listings. Build targeted contact lists by route or destination. Ideal for travel marketers and agencies.",
        "version": "0.1",
        "x-build-id": "BlUVKjATEHGQfBGcT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~kayak-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-kayak-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/scraper-engine~kayak-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-kayak-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/scraper-engine~kayak-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-kayak-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 Kayak (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Kayak profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Kayak"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Kayak"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```