# Booking Com Email Scraper Fast Advanced And Cheapest (`scraperoka/booking-com-email-scraper-fast-advanced-and-cheapest`) Actor

🚀 Booking.com Email Scraper Fast Advanced & Cheapest extracts guest/partner emails quickly with advanced targeting and low-cost pricing. Ideal for lead gen, outreach, and B2B growth. 📈 Save time, boost conversions, stay compliant.

- **URL**: https://apify.com/scraperoka/booking-com-email-scraper-fast-advanced-and-cheapest.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 - Fast, Advanced and Cheapest 🎯

Manually hunting for contact emails one listing at a time wastes hours you don’t have. **Booking.Com Email Scraper - Fast, Advanced and Cheapest** extracts email addresses from Booking.com using your keywords and email-domain filters—ideal for marketers, recruiters, and growth teams. This Booking.com email scraper helps you build a targeted Booking.com email database in a single run, often reaching thousands of records quickly.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "network": "Booking.com.com",
  "keyword": "manager",
  "title": "Property Manager",
  "description": "Email contact details available on the public listing page.",
  "url": "https://www.booking.com/example-property.html",
  "email": "manager@example.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Which collection source this lead belongs to (always `Booking.com.com` in this actor) |
| `keyword` | string | The keyword used to find the contact, so you can segment leads by intent |
| `title` | string | The lead title or heading captured from the result item |
| `description` | string | The text block where the email was detected (useful context for validation) |
| `url` | string | The page URL tied to that lead for traceability |
| `email` | string | The extracted email address you can use for outreach |

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

***

### Why Booking.Com Email Scraper - Fast, Advanced and Cheapest?

There are a lot of ways to pull contact data from publicly available web sources — here’s what sets **Booking.Com Email Scraper - Fast, Advanced and Cheapest** apart.

#### Fast bulk extraction with keyword-driven lead targeting

You control what you search for using the `keywords` input, plus optional `location` filtering. That means you’re not collecting random emails—you’re extracting emails from Booking.com listings aligned to your outreach themes (a core advantage for advanced Booking.com email extraction).

#### Domain filtering for higher list relevance

With `customDomains`, you can focus on the email extensions that match your business goals (for example `@gmail.com` or `@yahoo.com`). This makes the Booking.com contact email scraper output more immediately usable for lead generation email scraper workflows.

#### Resumable runs for reliability

If a run stops early or you need to interrupt it, the actor maintains progress so it can resume later. This helps protect your work when you’re scaling automated Booking.com email scraping.

#### Clear, structured dataset output

Each lead is written in a consistent structure to the dataset, including the `keyword`, `title`, `description`, `url`, and the extracted `email`. That structure makes it easy to clean, deduplicate, and import into CRMs or spreadsheets after your Booking.com email scraper API run.

***

### Configuring Your Run

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

```json
{
  "keywords": ["manager", "founder"],
  "location": "Lisbon",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 50
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords the actor uses to find relevant Booking.com lead candidates |
| `location` | ⬜ | Filters results by a specific location (leave empty if you want broader coverage) |
| `customDomains` | ⬜ | Restricts extracted contacts to the email domains you specify (for example `@gmail.com`) |
| `maxEmails` | ⬜ | Stops the run after the actor collects up to this many unique emails (helps control run length and cost) |

***

### Core Capabilities

#### Keyword-based email extraction

The actor uses your provided `keywords` to drive the search for relevant Booking.com contacts. This is the foundation behind a fast Booking.com email finder that’s tuned to your lead criteria.

#### Custom email-domain targeting

By setting `customDomains`, you filter which emails are accepted during extraction. For many teams, this is what turns an automated Booking.com email scraping project into a “right leads only” pipeline.

#### Deduplicated unique email handling

The actor keeps track of seen emails and avoids pushing duplicates. That helps maintain a cleaner Booking.com business email scraper result set.

#### Incremental dataset writing

Leads are pushed to the dataset as they are found, not only after the run finishes. This makes the actor suitable for workflows that require ongoing progress checks during a run.

#### Run control with `maxEmails`

If you’re trialing or testing lead quality, set `maxEmails` to cap the run. The actor also enforces a free-user maximum of 100 emails (while paid users can run without that restriction).

***

### Who Gets the Most Out of This

Here’s how different teams put **Booking.Com Email Scraper - Fast, Advanced and Cheapest** to work:

**Marketing teams** use it to build targeted prospect lists based on job-relevant keywords (like `manager` or `founder`) and preferred email domains. They leave the run with a structured dataset that’s ready for outreach.

**Recruiters and staffing teams** use the keyword inputs to find property-related leadership contacts and then validate them using the provided `url` and `description` context. The result is less manual searching and faster list building.

**Sales development reps** run multiple domain-focused searches to match their ideal lead accounts, then import the email list into their CRM for follow-ups. Domain filtering helps reduce time spent on irrelevant contacts.

**Data analysts and researchers** treat the dataset as an event log of extracted contacts tied to `keyword`, `title`, and `url`. This makes it easier to analyze which keywords produce the best-quality Booking.com email scraper output.

**Automation specialists / technical teams** can trigger the actor through Apify’s API and pipe results downstream for enrichment, scoring, and routing—using the consistent dataset fields as a stable interface for pipelines.

***

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

No coding needed. Here's how to run **Booking.Com Email Scraper - Fast, Advanced and Cheapest** from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open the actor page for this Booking.com email scraper.
2. **Enter your inputs** — add `keywords` (required), and optionally set `location`, `customDomains`, and `maxEmails` in the input panel.
3. **Configure proxy settings** — choose your proxy preference in the Run options for reliable scraping at scale.
4. **Hit Run and watch the live log** — monitor progress in real time as results are pushed to the dataset.
5. **View results in the dataset tab** — check the “Scraped Leads” dataset with fields like `keyword`, `url`, and `email`.
6. **Export as JSON, CSV, or Excel** — download directly from the dataset view when you’re happy with the output.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Booking.Com Email Scraper - Fast, Advanced and Cheapest** plugs directly into your existing workflow. You can export results in JSON, CSV, or Excel straight from the Apify dataset tab.

If you want automation, you can connect the actor via Apify API to pull results programmatically, or wire it into tools like Zapier/Make for no-code routing when the run completes. For deeper automation patterns (including webhooks and scheduled runs), refer to Apify’s documentation at https://apify.com/docs/api.

***

### Pricing & Free Trial

**Booking.Com Email Scraper - Fast, Advanced and Cheapest** runs on the Apify platform, which offers a **free tier** — no credit card required to get started. From there, usage typically follows Apify’s pay-as-you-go model based on platform compute, with pricing details available on Apify’s pricing page.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limits and blocks | Uses built-in resiliency and fallback behavior to keep extraction going |
| Resumability | Saves progress so you can continue without starting from zero |
| Result caps | Stops when `maxEmails` is reached to control run duration |
| Output consistency | Pushes structured lead records to the dataset as they are found |
| Unique email tracking | Avoids pushing the same email multiple times |

**Limitations:** The actor extracts emails from publicly available content. It can only collect what’s exposed on those pages, and results may be limited if there are fewer matching contacts for your keywords and domains.

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

***

### Frequently Asked Questions

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

Yes. Apify offers a **free tier**, and smaller runs typically work well for testing. If you need more than the free tier limits, use a paid plan on Apify.

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

No. This actor extracts emails from publicly available sources tied to the Booking.com pages it accesses, so you don’t need a user login.

#### How accurate is the data?

Accuracy depends on what’s published on the pages. The actor extracts email addresses that match your `customDomains` filters and pushes the associated `url` and `description` context into the dataset so you can validate each lead.

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

You control this with `maxEmails`. The actor stops when it reaches the unique email limit you set (and free users are capped at a maximum of 100 emails).

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

The freshness depends on when you run the actor and what’s currently visible on the pages. The dataset reflects the content available during the run.

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

The actor collects **publicly available data**. You are responsible for complying with GDPR, CCPA, platform ToS, and any other applicable local laws when you store, process, and use the emails.

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

Yes. You can export your dataset from the Apify dashboard in JSON, CSV, or Excel. From there, you can import into Google Sheets or other tools as needed.

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

Yes. You can schedule actor runs using Apify’s scheduling options. Check Apify documentation for details on how to set up recurring executions.

#### Can I access this via API?

Yes. You can call the actor via Apify API to run jobs and fetch results programmatically. See https://apify.com/docs/api for API documentation.

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

The actor writes results incrementally and maintains progress so you can resume. If errors occur during pushing, those specific lead pushes can fail without stopping the entire run.

***

### Need Help or Have a Request?

Got a question about **Booking.Com Email Scraper - Fast, Advanced and Cheapest** or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like webhook notifications on completion and batch CSV upload support. This Booking.com scraper is actively maintained based on user feedback.

***

### Disclaimer & Responsible Use

*Booking.Com Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to extract booking leads by email—start your free run today.*

**This actor collects publicly available data**. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for ensuring your use of the extracted data complies with GDPR, CCPA, platform ToS, and any 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 or queries to search for.

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

Location to filter search results.

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

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/booking-com-email-scraper-fast-advanced-and-cheapest").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": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Booking Com Email Scraper Fast Advanced And Cheapest",
        "description": "🚀 Booking.com Email Scraper Fast Advanced & Cheapest extracts guest/partner emails quickly with advanced targeting and low-cost pricing. Ideal for lead gen, outreach, and B2B growth. 📈 Save time, boost conversions, stay compliant.",
        "version": "1.0",
        "x-build-id": "GoDjq44OZ2TlXmCy4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~booking-com-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-booking-com-email-scraper-fast-advanced-and-cheapest",
                "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-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-booking-com-email-scraper-fast-advanced-and-cheapest",
                "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-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-booking-com-email-scraper-fast-advanced-and-cheapest",
                "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 or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter 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
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
