# Booking Com Email Scraper (`scraperoka/booking-com-email-scraper`) Actor

📧 Booking Com Email Scraper extracts guest & property contact emails from Booking.com listings. 🚀 Perfect for lead generation, B2B outreach, and market research—fast, accurate, and easy to use. 💼

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

## Pricing

from $0.01 / 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

### Booking.com Email Scraper 🎯

Manually hunting for contact emails across Booking.com profiles wastes hours you don’t have. **Booking.com Email Scraper** automatically extracts emails tied to Booking.com profile bios using your chosen keywords and email-domain filters. The Booking.com email scraper is ideal for marketers, recruiters, and growth teams who need to build lead lists fast—collecting thousands of contacts in minutes.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "network": "Booking.com.com",
  "keyword": "hotel",
  "title": "Luxury Boutique Hotel • Contact Details",
  "description": "For bookings and inquiries: reservations@stayboutique.com • Located in city center.",
  "url": "https://example.com/some-property-page",
  "email": "reservations@stayboutique.com",
  "proxyGroups": [
    "legacy"
  ]
}
````

**Output Fields**

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the data source network returned for this record (always `Booking.com.com`). |
| `keyword` | string | The keyword you searched for when the email was discovered—useful for segmenting your Booking.com contact email scraper output. |
| `title` | string | The title text associated with the result where the email was found, helping you understand context at a glance. |
| `description` | string | The surrounding text that contained the email—helpful for verification and auditing. |
| `url` | string | The source URL where the email context came from, so your team can trace back the record. |
| `email` | string | The extracted contact email address (filtered using your `customDomains`). |
| `proxyGroups` | array | The proxy configuration details used for the run (useful for troubleshooting and run auditing). |
| `charged_event_name` | (not included in dataset row) | Data is pushed with `charged_event_name="result"` when records are stored (see run behavior in the logs/dataset events). |
| `error_message` | (not included in dataset row) | Note: this actor pushes result rows via `Actor.push_data(row, ...)` / `push_data` and the dataset row fields shown above are what you should expect. |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Booking.com Email Scraper?

There are a lot of ways to pull data from Booking.com — here's what sets **Booking.com Email Scraper** (booking.com scraper emails, booking.com email harvesting tool) apart.

#### Keyword-driven targeting

You provide a list of `keywords`, and the actor uses them to find emails from Booking.com profile bios related to your terms. This makes the booking.com email list scraper output more relevant to your outreach and research goals.

#### Domain filters for cleaner lead lists

Use `customDomains` (for example `@gmail.com`) to focus on specific email providers and reduce irrelevant results. This is especially useful when you’re using a booking.com email crawler for lead generation.

#### Built for resilient bulk runs

The actor includes retries and fallback behavior when pages don’t return usable results. For larger searches or higher `maxEmails`, plan for longer runs and adjust Run Options timeout when needed.

#### Stops when you hit your target

The actor tracks unique emails and stops once `maxEmails` is reached. That helps you control runtime costs while still giving the booking.com data scraper email enough room to find quality matches.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "keywords": ["hotel", "boutique"],
  "location": "Berlin",
  "platform": "Booking.com",
  "customDomains": ["@gmail.com", "@company.com"],
  "maxEmails": 50,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | Keywords used to look for Booking.com profile bios that contain relevant emails. |
| `location` | ⬜ | Location to filter search results (leave empty for no location filter). |
| `platform` | ⬜ | Selects the platform; the only available option is `Booking.com`. |
| `customDomains` | ⬜ | Filters extracted emails to only include addresses that match your provided email domains (for example `@gmail.com`). |
| `maxEmails` | ⬜ | Maximum number of emails to collect; the actor stops once this limit is reached. Helps control scraping time and cost. |
| `engine` | ⬜ | Choose the scraping engine: `cost-effective` (Cost Effective) or `legacy` (Legacy). |
| `proxyConfiguration` | ⬜ | Configure proxies for the run. If you want more reliability, enable proxy support for larger searches. |

***

### Core Capabilities

#### Extracts emails from publicly visible Booking.com bios

Booking.com Email Scraper focuses on extracting emails that appear in Booking.com bios/posts related to your keywords. This is why it works well for “extract booking.com emails” and “booking.com property email scraper” style workflows.

#### Flexible input for real-world targeting

You can pass multiple `keywords`, optionally set a `location`, and constrain results with `customDomains`. That combination makes the booking.com contact email scraper output more useful for outreach lists and segmentation.

#### Resilient scraping behavior for long runs

The actor is designed to keep going when a page doesn’t return results as expected. It uses retry logic and fallbacks to improve outcomes on larger searches.

#### Deduplicates emails during a run

It maintains a set of `seen_emails` so the same email isn’t repeatedly collected within the same run. This helps your booking.com email scraping software output stay cleaner without extra post-processing.

#### Real-time dataset writing

As soon as an email is found, the actor pushes a result row into your Apify dataset. That means you can monitor progress and export when you’ve collected what you need.

***

### Who Gets the Most Out of This

Here’s how different teams put Booking.com Email Scraper to work:

**Lead generation and growth teams** — they feed in keywords like “hotel” or “boutique,” restrict providers via `customDomains`, and quickly build a booking.com lead generation email scraper list they can upload to outreach tools. The outcome is a ready-to-contact dataset tied to relevant Booking.com bios.

**Recruiters and talent sourcers** — they can use keyword variations (and optionally location) to find roles or business contact emails that appear in profile descriptions. The result is less manual searching and faster shortlisting for outreach.

**Marketing and partnerships managers** — they run focused keyword batches and use `maxEmails` to cap each test run. That supports experimentation (narrow vs broader terms) while keeping costs predictable, turning booking.com scraper emails into actionable lists.

**Researchers and data analysts** — they can export structured results (including `title`, `description`, and `url`) for auditability. This makes the booking.com email list scraper output easier to validate, filter, and analyze downstream.

**Developers and automation specialists** — they can trigger the actor via the Apify platform and pipe dataset results into their systems. Booking.com Email Scraper is a practical building block for workflows that need booking.com email harvesting tool outputs automatically.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Booking.com Email Scraper from start to finish:

1. **Open the actor on Apify** — go to the Apify actor page at [console.apify.com](https://console.apify.com).
2. **Enter your inputs** — set `keywords` (required) and optionally `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — use the `proxyConfiguration` field if you want more reliable runs, especially for larger searches.
4. **Pick your engine** — choose `engine` as `legacy` or `cost-effective` based on your reliability vs speed preference.
5. **Hit Run and watch the live log** — confirm progress and monitor when records are found.
6. **View results in the dataset tab** — your exported rows appear as they’re pushed by the actor.
7. **Export as JSON, CSV, or Excel** — download your dataset in the format you need for outreach or analysis.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Booking.com Email Scraper plugs directly into your existing workflow.

You can download your results as JSON, CSV, or Excel from the Apify dataset tab. For deeper automation, you can connect the actor to tools via Apify’s integrations, Zapier / Make-style workflows, and API-driven pipelines.

You can also schedule runs for recurring lead refreshes, and use webhooks to trigger downstream actions (like pushing results to your CRM or analyst pipeline). For full details, refer to Apify’s documentation for API and integrations: <https://apify.com/docs/api>.

***

### Pricing & Free Trial

Booking.com Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. The platform includes an initial amount of credits for testing, then you scale using Apify’s pay-as-you-go billing model.

Actual costs depend on your run usage and the selected settings, so check the current pricing on the Apify pricing page. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limit and access variability | Includes retries and fallback behavior to improve success rates on larger runs. |
| Proxy support | Built-in proxy configuration support helps improve reliability when scraping at scale. |
| Controlled output size | `maxEmails` stops the run once you hit your target. |
| Data freshness for lead lists | Runs collect newly found publicly visible emails during each run. |
| Run interruptions | Results are pushed into your dataset as they’re found, so you can export partial results if you stop a run. |

**Limitations:** This actor only works with publicly visible information that appears on Booking.com bios/posts related to your keywords. It can’t access login-gated or private content, and extracted emails depend on what’s published publicly.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify provides a free tier so you can test Booking.com Email Scraper before scaling up.

#### Do I need to log in to Booking.com to use this?

No. This actor scrapes emails from publicly available sources, so no Booking.com login is required for operation.

#### How accurate is the data?

Accuracy depends on what’s published in the relevant Booking.com bios/posts. The actor extracts emails that match your `customDomains`, so accuracy is strongest when you filter to the domains your team cares about.

#### How many results can I get per run?

You can collect up to `maxEmails` unique emails per run. If you set a higher limit, you allow more potential results, but it doesn’t guarantee reaching that number.

#### How often is the data updated / how fresh is it?

Each run collects whatever publicly available data matches your inputs at the time of the run. For fresher leads, schedule repeated runs with the same keyword/domain filters.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor accesses **publicly available data**. You are responsible for ensuring your use complies with GDPR, CCPA, the platform’s Terms of Service, and any applicable local regulations.

#### Can I export results to Google Sheets or Excel?

Yes. You can export your dataset from the Apify dashboard as JSON, CSV, or Excel, and use automations/integrations to push into tools like Google Sheets if your workflow supports it.

#### Can I run this on a schedule automatically?

Yes. You can schedule the actor to run automatically on a cron-style schedule using Apify’s scheduling capabilities.

#### Can I access this via API?

Yes. You can trigger the actor and retrieve results programmatically via Apify’s API. See Apify API documentation here: <https://apify.com/docs/api>.

#### What happens if the actor hits an error?

If pages fail to return results, the actor uses retry logic and fallback behavior to continue. If the run still can’t proceed, it will stop according to the run conditions (including `maxEmails`) while preserving already pushed dataset records.

***

### Need Help or Have a Request?

Got a question about Booking.com Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome feature requests like batch CSV upload and webhook notifications on completion, and we actively maintain this actor based on feedback.

***

### Disclaimer & Responsible Use

*Booking.com Email Scraper is the fastest, most reliable way to build booking.com outreach email lists — start your free run today.*

This actor collects **publicly available data** from Booking.com bios/posts related to your keywords. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform Terms of Service, and any other applicable regulations. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

A list of keywords to search for.

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

Location to filter search results.

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

Select platform.

## `customDomains` (type: `array`):

List of custom email domains

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

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## `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`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "hotel"
  ],
  "location": "",
  "platform": "Booking.com",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy"
}
```

# 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": [
        "hotel"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/booking-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": ["hotel"],
    "location": "",
    "customDomains": ["@gmail.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/booking-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": [
    "hotel"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call scraperoka/booking-com-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Booking Com Email Scraper",
        "description": "📧 Booking Com Email Scraper extracts guest & property contact emails from Booking.com listings. 🚀 Perfect for lead generation, B2B outreach, and market research—fast, accurate, and easy to use. 💼",
        "version": "0.0",
        "x-build-id": "NdneiD5LNudNzJCxg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~booking-com-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-booking-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/scraperoka~booking-com-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-booking-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/scraperoka~booking-com-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-booking-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": "A list of keywords to search for.",
                        "default": [
                            "hotel"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Booking.com"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Booking.com"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "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": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
