# Zillow B2b Email Scraper (`scrapio/zillow-b2b-email-scraper`) Actor

- **URL**: https://apify.com/scrapio/zillow-b2b-email-scraper.md
- **Developed by:** [Scrapio](https://apify.com/scrapio) (community)
- **Categories:** Agents, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

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

### **Zillow** Email Scraper 📱

**Zillow** B2B Email Scraper allows users to **extract** a wide range of **data** from **Zillow**'s platform, enabling comprehensive lead generation. It is designed to gather **contact** information and property details efficiently.

The tool focuses on **extract**ing business **emails** of real estate agents, brokers, and property managers. Additionally, users can obtain property **data** such as addresses, prices, and listing details.

This **data** can be used for marketing, networking, and business development purposes. The scraper ensures that all **extract**ed **data** is accurate and up-to-date, making it a reliable resource for real estate professionals.

By automating the **data** **extract**ion process, the tool saves time and effort while delivering high-quality results.

Zillow B2B Email Scraper is a powerful tool designed to help businesses extract valuable contact information from Zillow for lead generation purposes. It simplifies the process of gathering real estate agent emails and other relevant data for B2B outreach.

With Zillow B2B Email Scraper, users can automate the tedious task of manually searching for real estate contacts. This tool is ideal for businesses looking to connect with real estate agents, brokers, and property managers.

The scraper is tailored for real estate professionals and B2B marketers who need accurate and up-to-date contact information. It ensures efficiency and precision in extracting data from Zillow's vast property listings.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.scrapio@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Agent Email | Business email addresses of real estate agents listed on Zillow. |
| Agent Name | Full names of real estate agents associated with property listings. |
| Property Address | Complete addresses of properties listed on Zillow. |
| Listing Price | Price details of properties available for sale or rent. |
| Phone Number | Contact phone numbers of real estate agents or brokers. |
| Property Type | Information on the type of property, such as residential or commercial. |
| Listing URL | Direct links to property listings for further reference. |
| Agent Website | Links to real estate agents' professional websites or profiles. |

### Key Features of **Zillow** Email Scraper

Here are the **standout features** that make the **Zillow** Email Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ Automates the extraction of business emails from **Zillow** listings
- ⭐ Retrieves detailed property information such as addresses and prices
- ⭐ **Customizable** filters to target specific locations or property types
- ⭐ Ensures accurate and up-to-date data collection for reliable results
- ⭐ User-friendly interface for seamless operation and minimal learning curve
- ⭐ Supports bulk data extraction to save time and improve efficiency
- ⭐ Compatible with various formats for easy data export and integration
- ⭐ Adheres to ethical data scraping practices to ensure compliance
- ⭐ Provides detailed logs for transparency and troubleshooting
- ⭐ Offers robust customer support for any technical issues or queries
- ⭐ Includes options for scheduling automated scraping tasks
- ⭐ **High**ly scalable to meet the needs of businesses of all sizes

### How to use **Zillow** Email Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Zillow** emails today:

1. ✅ **Sign up** for an account on the **Zillow** B2B Email Scraper platform
2. ✅ Log in to the dashboard using your credentials
3. ✅ Enter the search criteria such as location property type or price range
4. ✅ **Select** the specific data fields you want to extract such as emails or property details
5. ✅ Set up any additional filters to refine your search results
6. ✅ Choose the output format for the extracted data such as CSV or JSON
7. ✅ Click the **Start** Scraping button to begin the data extraction process
8. ✅ Monitor the progress of the scraping task in real-time on the dashboard
9. ✅ Once completed download the extracted data from the provided link
10. ✅ **Review** the data to ensure accuracy and completeness
11. ✅ Use the data for lead generation marketing or other business purposes
12. ✅ Contact customer support if you encounter any issues during the process

### Use Cases 🎯

Real Estate Lead Generation
🎯 Generate a list of real estate agent emails for marketing campaigns
🎯 **Identify** potential clients or partners in the real estate industry

Property Market Analysis
🎯 Extract property prices and details for market trend analysis
🎯 Compare property listings across different regions or categories

Networking with Real Estate Professionals
🎯 Connect with real estate agents and brokers for business opportunities
🎯 Build a database of real estate professionals for future outreach

Customized Data Solutions
🎯 Create tailored datasets for specific business needs
🎯 Integrate extracted data into CRM or marketing tools

### Why choose us? 💎

**Zillow** B2B Email Scraper is designed with the needs of real estate professionals and B2B marketers in mind. Our tool simplifies the process of extracting business emails and property data from **Zillow**, saving you time and resources.

We prioritize accuracy and reliability, ensuring that the data you receive is up-to-date and relevant. Our **user-friendly** interface makes it easy for anyone to use the scraper, regardless of technical expertise.

We also offer robust customer support to assist you with any questions or issues you may encounter. By choosing **Zillow** B2B Email Scraper, you gain access to a powerful real estate email extractor that enhances your lead generation efforts.

Our tool is highly customizable, allowing you to tailor the data extraction process to your specific needs. Whether you're a small business or a large enterprise, our scraper is **scalable** to meet your requirements.

Trust us to provide a seamless and efficient solution for your real estate data scraping needs.

### **Zillow** Email Scraper Scalability 📈

**Zillow** B2B Email Scraper is built to handle data extraction tasks of any size. Whether you need a small dataset or a **large-scale** operation, our tool can scale to meet your requirements.

The scraper supports bulk data extraction, allowing you to gather thousands of records in a single session. This makes it an ideal choice for businesses of all sizes, from startups to large enterprises.

Our platform is designed to maintain performance and reliability even during high-volume scraping tasks. Additionally, the tool offers scheduling options, enabling you to automate recurring data extraction processes.

With **Zillow** B2B Email Scraper, you can grow your business without worrying about the limitations of your data scraping solution.

### **Zillow** Email Scraper Legal Guidelines ⚖️

**Yes**—scraping **Zillow** is **legal** as long as you follow **ethical** and **compliant** practices. The **Zillow** Email Scraper extracts only **publicly available** information from **public** **Zillow** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Zillow**s terms of service before using the scraper
⚖️ **Do not** use the scraper for unauthorized or unethical purposes
⚖️ **Avoid** scraping personal data that is not publicly available or permitted
⚖️ **Use** the extracted data responsibly and in accordance with data protection regulations
⚖️ **Do not** resell or distribute the extracted data without proper authorization
⚖️ **Ensure** transparency and obtain consent when contacting leads from the extracted data
⚖️ Regularly review legal updates related to data scraping and adjust practices accordingly
⚖️ Consult with legal professionals if you are unsure about the legality of your data usage

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Zillow B2B Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Zillow",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails to collect (default 20) |
| platform | Platform to scrape (Zillow) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Zillow",
    "keyword": "Zillow B2B Email Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "email": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Zillow as the source |
| keyword | Keyword that triggered the result (Zillow B2B Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Zillow profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Zillow B2B **Email Scraper**?

Zillow B2B Email Scraper is a tool designed to extract business **emails** and other relevant data from Zillow for lead generation purposes.

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

You can extract agent **emails**, names, property addresses, listing prices, phone numbers, and more.

#### Is the scraper easy to use?

**Yes**, the tool features a **user-friendly** interface that makes it easy for anyone to operate.

#### Can I customize the data **extract**ion process?

**Yes**, the scraper allows you to set filters and select specific data fields to extract.

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

The scraper ensures that all data is accurate and up-to-date by pulling information directly from Zillow.

#### Can I use the scraper for bulk data **extract**ion?

**Yes**, the tool supports bulk data extraction, making it suitable for large-scale operations.

#### Is the scraper compliant with data protection laws?

**Yes**, the tool adheres to ethical data scraping practices and encourages **compliance** with legal guidelines.

#### What output formats are supported?

The scraper supports various formats, including **CSV** and **JSON**, for easy data export.

#### Can I schedule automated scraping tasks?

**Yes**, the tool includes scheduling options for recurring data extraction tasks.

#### What is the pricing for Zillow B2B **Email Scraper**?

Pricing details can be found on our website or by contacting our sales team.

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

**Yes**, we offer robust customer support to assist with any technical issues or queries.

#### Can I use the scraper for market analysis?

**Yes**, the tool is ideal for extracting property data for market trend analysis.

#### Is the tool scalable for large enterprises?

**Yes**, Zillow B2B Email Scraper is **highly scalable** and can handle data extraction tasks of any size.

#### What are the system requirements for using the scraper?

The tool is web-based and requires an internet connection and a modern web browser.

#### How do I get started with Zillow B2B **Email Scraper**?

Sign up for an account on our platform, log in, and follow the step-by-step instructions to begin extracting data.

# Actor input Schema

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

List of keywords to search for on Zillow (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Zillow profiles/posts containing these keywords and extract email addresses.

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

Select platform.

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

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

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

Maximum number of emails to collect per keyword (default: 20).

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

## `proxyConfiguration` (type: `object`):

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Zillow",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapio/zillow-b2b-email-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapio/zillow-b2b-email-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapio/zillow-b2b-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow B2b Email Scraper",
        "version": "0.1",
        "x-build-id": "9eF1dt9cGzZOzXME0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapio~zillow-b2b-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapio-zillow-b2b-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/scrapio~zillow-b2b-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapio-zillow-b2b-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/scrapio~zillow-b2b-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapio-zillow-b2b-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Zillow (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Zillow profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Zillow"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Zillow"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```