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

📧 Kayak Email Scraper (kayak-email-scraper) extracts emails from Kayak pages to speed up lead research and outreach. 🚀 Great for B2B sales, marketing, and contact building. Efficient, accurate, and time-saving. ✅

- **URL**: https://apify.com/scrapeengine/kayak-email-scraper.md
- **Developed by:** [ScrapeEngine](https://apify.com/scrapeengine) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

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

Kayak Email Scraper allows users to **extract** valuable **contact** information from Kayak listings with ease. This includes email addresses, business names, phone numbers, and other relevant details.

The tool is designed to provide structured and accurate **data** for marketing and outreach purposes. By using this scraper, you can gather information from travel agencies, hotels, and other businesses listed on Kayak.

It supports bulk **data** **extract**ion, ensuring you can collect large amounts of information in a short time. The **extract**ed **data** is organized in a clear and accessible format, making it easy to integrate into your existing systems.

This scraper is perfect for businesses looking to enhance their lead generation efforts and connect with potential clients in the travel industry.

Kayak Email Scraper is an advanced tool designed to extract email addresses and contact details from Kayak listings efficiently. It enables businesses and marketers to gather valuable leads from Kayak's travel-related data.

With Kayak Email Scraper, you can streamline your lead generation process by harvesting contact information from Kayak's extensive database. This tool is ideal for businesses in the travel and hospitality industry looking to expand their reach.

The scraper is user-friendly and built to handle large volumes of data, making it a reliable choice for extracting emails from Kayak. It ensures accurate and organized data collection to meet 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 |
| --- | --- |
| Email Addresses | Extract email addresses associated with Kayak listings for easy outreach. |
| Business Names | Retrieve the names of businesses listed on Kayak for better identification. |
| Phone Numbers | Collect phone numbers provided in Kayak listings for direct communication. |
| Website URLs | Extract website links from Kayak profiles to explore more details about the businesses. |
| Location Details | Gather location information such as city, state, and country from Kayak listings. |
| Business Categories | Identify the categories or types of businesses listed on Kayak for targeted outreach. |
| Ratings and Reviews | Extract ratings and reviews from Kayak listings to assess business credibility. |
| Descriptions | Retrieve descriptions or summaries provided in Kayak listings for additional insights. |

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

- ⭐ Efficiently extracts email addresses and contact details from Kayak listings
- ⭐ Supports bulk data extraction for handling large volumes of information
- ⭐ Provides structured and organized data output for seamless integration
- ⭐ User-friendly interface with easy-to-follow instructions for smooth operation
- ⭐ **Customizable** scraping options to target specific data fields or listings
- ⭐ Ensures high accuracy and reliability in the extracted data
- ⭐ Compatible with various formats for exporting data such as CSV and JSON
- ⭐ Automates the data extraction process to save time and effort
- ⭐ Offers robust data filtering options to refine search results
- ⭐ Includes regular updates to maintain compatibility with Kayaks platform
- ⭐ **Secure** and compliant with data privacy regulations to protect user information
- ⭐ Provides detailed documentation and customer support for troubleshooting

### 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 an account on the Kayak Email Scraper platform
2. ✅ Log in to your account and navigate to the dashboard
3. ✅ Enter the specific search criteria or keywords for the Kayak listings you want to scrape
4. ✅ **Select** the data fields you wish to extract such as emails phone numbers or business names
5. ✅ **Configure** any additional settings such as location filters or scraping limits
6. ✅ **Start** the scraping process by clicking the Run button
7. ✅ Monitor the progress of the scraping task through the dashboard
8. ✅ Once completed download the extracted data in your preferred format such as CSV or JSON
9. ✅ **Review** the data to ensure accuracy and completeness
10. ✅ **Integrate** the extracted data into your CRM or marketing tools for further use
11. ✅ Repeat the process as needed for additional listings or updated data
12. ✅ Contact customer support if you encounter any issues or need assistance

### Use Cases 🎯

Lead Generation for Travel Agencies
🎯 Extract contact details of travel agencies listed on Kayak
🎯 Build a database of potential clients for marketing campaigns

Business Outreach for Hotels
🎯 **Collect** email addresses and phone numbers of hotels on Kayak
🎯 Reach out to hotels for partnerships or promotional opportunities

Market Research and Analysis
🎯 Gather data on business categories and locations from Kayak listings
🎯 **Analyze** trends and patterns in the travel industry for strategic planning

Competitor Analysis
🎯 Extract information on competitors listed on Kayak
🎯 **Study** their ratings reviews and descriptions for benchmarking

Email Marketing Campaigns
🎯 **Use** extracted email addresses to launch targeted email campaigns
🎯 Promote travel-related services or products to potential clients

### Why choose us? 💎

Kayak Email Scraper is designed to deliver accurate and **reliable** data extraction from Kayak listings. Our tool is **user-friendly** and offers a seamless experience for businesses of all sizes.

With customizable options, you can tailor the scraping process to meet your specific needs. We prioritize data accuracy, ensuring that the extracted information is clean and ready for use.

Our software is built to handle large-scale data extraction, making it a perfect choice for businesses looking to scale their lead generation efforts. We also provide excellent customer support to assist you at every step of the process.

By choosing our Kayak Email Scraper, you gain access to a powerful tool that saves time, reduces manual effort, and enhances your marketing and outreach strategies. Trust us to help you connect with the right leads and grow your business effectively.

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

Kayak Email Scraper is built to handle data extraction tasks of any size, making it suitable for both small businesses and large enterprises. The tool supports bulk data scraping, allowing you to gather information from thousands of Kayak listings in a single session.

It is optimized for speed and efficiency, ensuring that you can extract data quickly without compromising accuracy. Whether you need a small dataset or a comprehensive database, our scraper can scale to meet your requirements.

Additionally, the software is regularly updated to ensure compatibility with Kayak's platform, so you can rely on it for long-term use. With robust infrastructure and **advanced** features, Kayak Email Scraper is a scalable solution for businesses aiming to expand their reach and maximize their marketing efforts.

### **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 when using the scraper
⚖️ **Do not** use the scraper for unauthorized or unethical purposes
⚖️ **Avoid** sharing or selling extracted data without proper consent
⚖️ Respect data privacy laws and regulations in your jurisdiction
⚖️ **Use** the scraper only for legitimate business purposes
⚖️ **Do not** scrape sensitive or personal information without authorization
⚖️ **Ensure** that the extracted data is stored securely to prevent breaches
⚖️ Regularly review and adhere to updates in data protection laws and policies

### 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 addresses and other contact details from Kayak listings.

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

**Yes**, Kayak Email Scraper is ideal for generating leads from Kayak's extensive database.

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

You can extract **emails**, business names, phone numbers, website URLs, and more from Kayak listings.

#### Is the **extract**ed data accurate?

**Yes**, the scraper is designed to provide accurate and reliable data extraction.

#### How do I download the **extract**ed data?

You can download the data in formats like **CSV** or **JSON** directly from the dashboard.

#### Is this tool **legal** to use?

**Yes**, as long as you comply with Kayak's terms of service and data privacy regulations.

#### Can I customize the scraping process?

**Yes**, the tool offers customizable options to target specific data fields or listings.

#### Does the scraper support bulk data **extract**ion?

**Yes**, it is designed to handle large-scale data extraction efficiently.

#### What industries can benefit from this tool?

Travel agencies, hotels, and marketing firms can benefit greatly from using this scraper.

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

**Yes**, we provide dedicated customer support to assist you with any issues.

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

**Yes**, you can apply filters to target listings from specific cities, states, or countries.

#### How often is the scraper updated?

The scraper is regularly updated to ensure compatibility with Kayak's platform.

#### Is the tool easy to use for **beginners**?

**Yes**, the scraper features a **user-friendly** interface and detailed instructions for easy use.

#### Can I integrate the **extract**ed data into my **CRM**?

**Yes**, the data is provided in formats that are easy to integrate into CRM systems.

#### What should I do if I encounter an issue?

You can contact our customer support team for assistance with any issues.

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapeengine/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 (kayak-email-scraper) extracts emails from Kayak pages to speed up lead research and outreach. 🚀 Great for B2B sales, marketing, and contact building. Efficient, accurate, and time-saving. ✅",
        "version": "0.1",
        "x-build-id": "aq9mw9zRV1udNktdb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeengine~kayak-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeengine-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/scrapeengine~kayak-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeengine-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/scrapeengine~kayak-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeengine-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
