# Expedia Email Scraper (`scraperoka/expedia-email-scraper`) Actor

📧 Expedia Email Scraper pulls verified contact emails from Expedia listings fast and accurately. Great for B2B lead generation, travel marketing & outreach—save time, reach prospects, and boost conversion rates 🚀

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

## Pricing

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

### Expedia Email Scraper 🎯

Manually visiting hundreds of listings to collect emails wastes hours you don’t have. **Expedia Email Scraper** finds contact emails from **Expedia** profiles using your **keywords** and **custom email-domain filters**, so you can build outreach lists fast. This Expedia email scraper is ideal for marketers, recruiters, and growth teams who need an **Expedia email list** at scale—often thousands of leads in a single run when you tune your inputs well.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "network": "Expedia.com",
  "keyword": "marketing",
  "title": "Marketing Lead at Travel Group",
  "description": "Marketing Lead focused on growth. Contact me at sara.travel@gmail.com for partnerships.",
  "url": "https://example.com/profile/sara-travel",
  "email": "sara.travel@gmail.com",
  "proxyGroups": [
    "cost-effective"
  ]
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the data source network (“Expedia.com”) for clean reporting |
| `keyword` | string | Shows which keyword produced the lead so you can audit search intent (e.g., founder vs marketing) |
| `title` | string | The result title context helps you judge relevance before outreach |
| `description` | string | Snippet text where the email was found—useful for qualification and personalization |
| `url` | string | The page URL tied to the record so you can verify and trace the source |
| `email` | string | The actual email address detected for outreach |
| `proxyGroups` | array | Records the proxy configuration used for transparency and troubleshooting |
| `error_message` | string | Error details when something goes wrong (when present in your run outputs) |
| `status` | string | Run/object status when your integration expects it (when present in your run outputs) |
| `success` | boolean | Indicates whether a record was produced successfully (when present in your run outputs) |

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

***

### Why Expedia Email Scraper?

There are a lot of ways to pull data from Expedia — here’s what sets Expedia Email Scraper apart.

#### Keyword and domain targeting for cleaner leads

Expedia Email Scraper uses your `keywords` to focus the results, and you can restrict matches with `customDomains` (for example, email domains like `@gmail.com`). This helps you build an **Expedia contacts email extraction** workflow that’s closer to real outreach needs.

#### Output records are structured for outreach workflows

Each pushed record includes the email plus the surrounding context (`title`, `description`, and `url`). That means your **Expedia outreach email scraper** output is ready for lead lists and qualification without frantic copy-pasting.

#### Resilience built for large runs

The actor includes retries and fallbacks for resilience when pages return empty results or requests fail. It’s designed to keep you moving through larger searches (with time controls via Run Options when needed).

#### Built-in proxy support for reliable scraping

You can configure proxies for this Actor using `proxyConfiguration`, and you can choose an `engine` mode for different performance/cost tradeoffs. This helps keep the Expedia email scraper results flowing even when conditions change.

***

### Configuring Your Run

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

```json
{
  "keywords": ["founder", "marketing"],
  "location": "",
  "platform": "Expedia",
  "customDomains": ["@gmail.com"],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for (used to find relevant Expedia bios/posts related to your lead criteria) |
| `location` | ⬜ | Filters search results by location (leave empty for no location filter) |
| `platform` | ⬜ | Selects the platform to scrape (enum contains `Expedia`) |
| `customDomains` | ⬜ | Restricts collected emails to specific email domains (for example, `@gmail.com`) |
| `maxEmails` | ⬜ | Caps the maximum number of emails to collect; helps control scraping time (min `1`, max `10000`) |
| `engine` | ⬜ | Choose scraping engine mode: `cost-effective` (Cost Effective (New)) or `legacy` (Legacy) |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor (useful for reliability on larger searches) |

***

### Core Capabilities

#### Keyword-based email harvesting

Expedia Email Scraper finds emails from Expedia bios and pages related to your `keywords`. If you’re running an **Expedia guest email extractor** workflow, this is the control you use to steer results toward the right intent.

#### Domain filtering for outreach relevance

Use `customDomains` to keep only emails that match your chosen patterns. This is especially useful when you need an **Expedia business email finder** list that matches specific recipient types (like consumer vs. business domains).

#### Pagination with stop conditions

The actor collects emails until it hits your `maxEmails` limit or the run reaches its internal stopping rules. This means you can safely test with small caps first, then scale up for **hotel listing email scraper** or **travel agency email scraper** projects.

#### Deduplication across the run

It tracks already seen emails during the run and avoids pushing duplicates. This keeps your **Expedia email harvesting tool** output cleaner for CRM import and reduces wasted manual cleanup.

#### Real-time dataset writing

As soon as a record is found, it’s pushed to the Apify dataset via `Actor.pushData`. If a run stops early, you still retain everything collected up to that point.

#### Proxy- and engine-aware execution

You can select `engine` and supply `proxyConfiguration` to improve reliability. For larger searches or higher `maxEmails`, this helps reduce interruptions while you collect an **Expedia email list** at scale.

***

### Who Gets the Most Out of This

Here’s how different teams put Expedia Email Scraper to work:

**Growth Marketers** — They run focused keyword sets (like `founder` and `marketing`) and restrict domains using `customDomains` to quickly assemble an outreach-ready **Expedia leads email scraper** list for campaigns.

**Sales Development Reps** — They test with a smaller `maxEmails` cap, validate lead quality from the `title`, `description`, and `url`, then rerun with broader keywords to expand their **Expedia email list** without wasting days prospecting manually.

**Hotel Operations & Partnerships** — They use keyword intent to target relevant roles and build a contact set tied to Expedia-related public profiles, helping partnerships move from research to outreach faster.

**Freelance Researchers & Analysts** — They rely on structured output fields (`network`, `keyword`, `email`, `url`) to build datasets and audit source context when validating lead relevance.

**Automation & Integration Specialists** — They trigger Expedia Email Scraper via the Apify API, export results in bulk, and connect the dataset to downstream workflows (like CRMs and email tools) for hands-off list building.

***

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

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

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open Expedia Email Scraper.
2. **Enter your inputs** — set `keywords` (required), then optionally `location`, `customDomains`, and `maxEmails`.
3. **Set your platform & engine** — keep `platform` as `Expedia`, and choose `engine` (`legacy` or `cost-effective`) based on your needs.
4. **Configure proxies** — if you’re running larger jobs, set `proxyConfiguration` for better reliability.
5. **Hit Run and watch the live log** — monitor progress and ensure the run is collecting emails as expected.
6. **View results in the dataset tab** — each discovered record is pushed to the dataset as it’s found.
7. **Export and use your data** — export your dataset as JSON, CSV, or Excel for your next workflow.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

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

You can export your dataset from the Apify dashboard in **JSON, CSV, or Excel** format. From there, you can import into your CRM, spreadsheets, or outreach tools with minimal friction.

For automation and connectivity, you can use **Apify’s native integrations** or tools like **Zapier** and **Make**, plus programmatic access via the **Apify API** (with optional **webhooks**). For deeper details, refer to Apify docs at [apify.com/docs/api](https://apify.com/docs/api).

***

### Pricing & Free Trial

Expedia Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. The free tier includes **$5 platform credits on sign-up**, which is enough for several test runs.

After that, it’s typically **pay-as-you-go**, billed per Actor compute unit (CU). You can scale using Apify’s plans for heavier usage, and you generally pay for Apify platform compute rather than a per-row listing fee.

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

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limiting and blocks | Uses retries and fallbacks so runs keep going when conditions are unfavorable |
| Proxy-based reliability | Supports proxy configuration for more stable large scraping runs |
| Empty/low-result pages | Applies logic to stop when results appear exhausted and continues when retries succeed |
| Large search runs | Designed to work with higher `maxEmails`, with guidance to adjust timeouts via Run Options when needed |

Limitations: This actor works on publicly available sources and collects emails that are discoverable there. If your chosen `keywords` are too narrow or your `customDomains` filters are restrictive, you may see fewer results—try broader keywords or more related 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 with **$5 platform credits** on sign-up, which is enough for several test runs.

#### Do I need to log in to Expedia to use this?

No. Expedia Email Scraper is designed to scrape emails from publicly available sources, so login-gated access is not required.

#### How accurate is the data?

Accuracy depends on what’s publicly available in the Expedia bios or related pages. The actor extracts emails that match your `customDomains` and associates them with the surrounding context (`title`, `description`, and `url`).

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

You control volume using `maxEmails` (min `1`, max `10000`). The actor stops once the limit is reached, but it does not guarantee reaching the exact number if fewer emails are discoverable with your filters.

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

Your results reflect what was publicly available at the time the run scraped the data. If you need fresher leads, schedule runs more frequently with Apify.

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

Yes in the sense that it collects **publicly available data**, but compliance depends on how you store and use it. You should follow GDPR/CCPA rules and applicable platform terms when using the exported emails.

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

Yes. You can export the dataset from the Apify dashboard as **JSON, CSV, or Excel**, and you can connect it to spreadsheets and workflows using automation tools.

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

Yes. You can schedule the actor to run automatically on a cron schedule using Apify’s scheduling options, so you can refresh your **Expedia email list** without manual effort.

#### Can I access this via API?

Yes. You can retrieve results programmatically via the Apify API, and you can integrate with your internal systems and pipelines using dataset outputs.

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

The actor includes resilience through retries and fallbacks. If a specific portion fails, runs are designed to continue pushing whatever results were successfully found up to that point.

***

### Need Help or Have a Request?

Got a question about Expedia Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to support custom keyword/domain strategies and ideas like webhook completion notifications or better batch workflow options.

***

### Disclaimer & Responsible Use

*Expedia Email Scraper is the fastest, most reliable way to build an Expedia outreach email list — start your free run today.*\
This actor collects **publicly available data** and does not access private profiles, login-gated content, or password-protected pages. You’re responsible for complying with GDPR, CCPA, platform Terms of Service, and any applicable local regulations when using the exported data. 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": [
    "founder",
    "marketing"
  ],
  "location": "",
  "platform": "Expedia",
  "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": [
        "founder",
        "marketing"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Expedia Email Scraper",
        "description": "📧 Expedia Email Scraper pulls verified contact emails from Expedia listings fast and accurately. Great for B2B lead generation, travel marketing & outreach—save time, reach prospects, and boost conversion rates 🚀",
        "version": "0.0",
        "x-build-id": "nH0TDDdv9dCkehWVq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~expedia-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-expedia-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~expedia-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-expedia-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~expedia-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-expedia-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": [
                            "founder",
                            "marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Expedia"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Expedia"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
