# Airbnb Email Scraper (`scraperoka/airbnb-email-scraper`) Actor

📧 Airbnb Email Scraper extracts verified host emails from Airbnb listings quickly and accurately. 🏡 Perfect for lead gen, market research, and outreach—save time, boost productivity, and scale campaigns with confidence. 🔎

- **URL**: https://apify.com/scraperoka/airbnb-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Travel
- **Stats:** 1 total users, 0 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

### AirBNB Email Scraper 🚀

Manually visiting AirBNB profiles to collect emails wastes hours you don’t have. **AirBNB Email Scraper** automatically scrapes emails from AirBNB bios using your chosen keywords and email-domain filters. This Airbnb email scraper finds contact leads for marketers, recruiters, and growth teams—so you can build an outreach list in minutes and scale to thousands of records in a single run.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "network": "AirBnB.com",
  "keyword": "founder",
  "title": "Host • Founder • Business travel setup",
  "description": "Hi! We run a hospitality team. Founder inquiries welcome. Contact: hello@gmail.com",
  "url": "https://www.example-airbnb.com/host-example",
  "email": "hello@gmail.com",
  "proxyGroups": ["GOOGLE_SERP"]
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network as `AirBnB.com` |
| `keyword` | string | The keyword that triggered the match (helps you segment leads) |
| `title` | string | The listing/profile result title you can use for context during outreach |
| `description` | string | The snippet text where the email was detected—useful for verification and filtering |
| `url` | string | The page URL tied to the found email (so you can trace it back) |
| `email` | string | The extracted email address you can put into your CRM |
| `proxyGroups` | array | Proxy group details used for the run (useful for debugging and traceability) |

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

***

### Why AirBNB Email Scraper?

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

#### Keyword-led lead discovery

AirBNB Email Scraper uses your `keywords` to find relevant AirBNB bios and posts related to those terms, helping you build an Airbnb leads email scraper output that’s aligned to your outreach angle.

#### Domain filtering for better targeting

Use `customDomains` (like `@gmail.com`) to focus results on the email domains you actually want—an Airbnb email finder tool approach that reduces wasted rows in your Airbnb email outreach list.

#### Resilient runs with stop conditions

The actor stops when `maxEmails` is reached, so you can control scraping time and cost while still gathering as many contacts as possible for your keyword + domain filters.

#### Structured records for downstream automation

Every pushed dataset record includes source context (`network`, `keyword`, `title`, `description`, `url`) alongside the `email`, so Airbnb contact details scraper outputs are integration-ready for analysis and outreach workflows.

***

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for when looking for relevant AirBNB bios |
| `location` | ⬜ | Location to filter search results (leave empty for no location filtering) |
| `platform` | ⬜ | Select platform. Only `AirBNB` is available |
| `customDomains` | ⬜ | List of custom email domains used to filter which emails are collected (for example `@gmail.com`) |
| `maxEmails` | ⬜ | Maximum number of emails to collect. The run stops once this limit is reached |
| `engine` | ⬜ | Choose the scraping engine: `cost-effective` or `legacy` |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor run (use Apify Proxy or your own proxy setup) |
| ↳ `proxy support` | ⬜ | Route requests through Apify Proxy for better reliability |

***

### Core Capabilities

#### Email extraction from AirBNB bios

AirBNB Email Scraper extracts emails found in AirBNB bios and posts related to your `keywords`. This makes it a practical Airbnb listing email extraction tool for lead generation and contact list building.

#### Flexible filtering with keywords and domains

You control the relevance with `keywords` and the targeting with `customDomains`. That combination helps you focus results for an Airbnb contact email scraping workflow instead of collecting broad, low-signal contacts.

#### Output includes context (not just emails)

Each dataset record includes the `title`, `description`, and `url` alongside the `email`, so your Airbnb email database isn’t just a raw email dump—it’s easy to validate and analyze.

#### Controlled scaling with `maxEmails`

Set `maxEmails` to cap how many emails the actor collects in one run. This helps you balance data quality and runtime, especially when you’re running Airbnb email scraping for emails at scale.

#### Proxy support for reliable scraping

The actor supports proxy configuration via the `proxyConfiguration` input, helping keep runs stable when scraping volumes increase.

***

### Who Gets the Most Out of This

AirBNB Email Scraper is built for teams that need real outreach contacts fast, including marketers building an Airbnb guest email scraper or Airbnb host email scraper audience and then turning it into an email outreach list.

Sales development reps use it to convert a list of target keywords into a ready-to-import database of Airbnb contact emails, saving hours of manual searching and copy-pasting.

Freelance researchers and data analysts benefit from the structured output fields (`title`, `description`, `url`, `keyword`) because it supports verification, filtering, and downstream scoring rather than only producing addresses.

Automation and integration specialists can plug the dataset into their pipeline—mapping `email` into a CRM and retaining `url` as a source reference for auditing and compliance workflows.

***

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

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

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find AirBNB Email Scraper.
2. **Enter your inputs** — set `keywords` (required) and optionally `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — if you expect higher volume, set up `proxyConfiguration` for better reliability.
4. **Hit Run and watch the live log** — monitor progress as emails are found and records are pushed to the dataset.
5. **View results in the dataset tab** — inspect the extracted `email` along with `title`, `description`, and `url`.
6. **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, **AirBNB Email Scraper** plugs directly into your existing workflow.

Export your dataset from the Apify dashboard as **JSON**, **CSV**, or **Excel**, then import it into your CRM, spreadsheet, or analysis tool.

You can also use the Apify platform to connect automation flows (including webhooks), schedule runs, and access results programmatically via the Apify API. For deeper setup details, see the official Apify docs: https://apify.com/docs/api

***

### Pricing & Free Trial

AirBNB Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You’ll be able to run several test jobs using platform credits, then scale based on your needs.

For exact costs and how runs are billed, check the current pricing 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 |
|---|---|
| Proxy support | You can configure proxies via `proxyConfiguration` for improved run stability |
| Targeting control | `keywords` and `customDomains` help reduce irrelevant results |
| Result limiting | `maxEmails` stops the run once the desired number of emails is reached |
| Resilience | The actor uses retry/fallback logic to handle blocked or empty result scenarios |
| Dataset writing | Records are pushed to the dataset as they’re found so you keep progress |

**Limitations:** This actor extracts emails from publicly available sources. If target bios don’t contain matching emails (or don’t match your `customDomains`), you may see fewer results. 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 with credits to help you test AirBNB Email Scraper before scaling. Exact free credit details depend on your Apify account and current plan rules.

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

No. AirBNB Email Scraper is designed to work with publicly available data and does not require an AirBNB login from you.

#### How accurate is the data?

Accuracy depends on what’s actually published in AirBNB bios and related public text where the actor detects email patterns. The dataset includes `description` and `url` so you can verify each lead.

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

You control results with `maxEmails`. The actor stops once it reaches your `maxEmails` cap, so you can run quick tests or larger scrapes with predictable output volume.

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

Freshness depends on when you run the actor. Each execution generates a new dataset from publicly available sources at runtime, so repeated runs will reflect newer published bios.

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

Using publicly available data is generally the correct starting point, but compliance depends on your use case and how you store and process the results. You’re responsible for ensuring your activities comply with GDPR, CCPA, and applicable platform terms.

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

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

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

Yes. You can schedule Apify actor runs using the Apify scheduling capabilities so your Airbnb email outreach list stays updated over time.

#### Can I access this via API?

Yes. You can retrieve results programmatically using the Apify API. See https://apify.com/docs/api for details.

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

If errors occur, you may see fewer results than expected, but the actor writes dataset records as it discovers them. You can re-run with adjusted `keywords`, broader `customDomains`, or a different `engine` setting if needed.

***

### Need Help or Have a Request?

Got a question about AirBNB Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like better export automation (for example, webhook on completion) and list-building improvements based on how you run Airbnb email extraction software.

***

### Disclaimer & Responsible Use

*AirBNB Email Scraper is the fastest, most reliable way to build an Airbnb email outreach list — start your free run today.*\
This actor extracts **publicly available data** and does not access private profiles, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform ToS, and applicable laws. 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": "AirBNB",
  "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/airbnb-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/airbnb-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/airbnb-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Email Scraper",
        "description": "📧 Airbnb Email Scraper extracts verified host emails from Airbnb listings quickly and accurately. 🏡 Perfect for lead gen, market research, and outreach—save time, boost productivity, and scale campaigns with confidence. 🔎",
        "version": "0.0",
        "x-build-id": "QT18ZzphBbJFEBazi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~airbnb-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-airbnb-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~airbnb-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-airbnb-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~airbnb-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-airbnb-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": [
                            "AirBNB"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "AirBNB"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
