# Zillow Email Scraper (`scraply/zillow-email-scraper`) Actor

📧 Zillow Email Scraper extracts real estate leads by pulling email addresses from Zillow listings. 🏡 Fast, accurate, and built for B2B prospecting, outreach, and market research. 🚀 Save time and boost conversions.

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

## Pricing

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

### **Zillow** Email Scraper 📱

**Zillow** Email Scraper allows users to **extract** a wide range of **data** from **Zillow** listings and agent profiles. This includes essential **contact** information such as email addresses, phone numbers, and agent names.

Users can also retrieve property details like price, location, and property type. The tool is designed to provide structured and accurate **data** for real estate professionals.

By automating the **extract**ion process, it eliminates manual **data** collection, saving time and ensuring consistency. With this tool, users can build a robust **data**base of real estate leads for marketing and outreach purposes.

It is an efficient solution for gathering **data** from **Zillow** while maintaining **data** accuracy and reliability.

Zillow Email Scraper is a powerful tool designed to extract email addresses and other contact information from Zillow listings quickly and efficiently. It is ideal for real estate professionals and businesses looking to streamline their lead generation process.

With this real estate email extractor, users can gather valuable contact details from property listings and agents on Zillow. This tool simplifies the process of obtaining accurate and organized data for real estate marketing campaigns.

Zillow Email Scraper is perfect for generating leads, connecting with property agents, and building a comprehensive database of real estate contacts. It saves time and effort by automating the data extraction process.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract email addresses of property agents and owners listed on Zillow. |
| Phone Numbers | Retrieve contact phone numbers associated with Zillow listings. |
| Agent Names | Collect the names of real estate agents managing the listings. |
| Property Prices | Gather property price details for listed real estate. |
| Property Locations | Extract location information such as city, state, and ZIP code. |
| Property Types | Identify property types like apartments, houses, or commercial spaces. |
| Listing Descriptions | Capture detailed descriptions of properties from Zillow listings. |
| Agent Profiles | Access additional details from agent profiles, such as agency information. |

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

- ⭐ **Automated** extraction of email addresses and contact details from **Zillow**
- ⭐ Ability to scrape property data such as prices locations and descriptions
- ⭐ User-friendly interface for seamless data extraction processes
- ⭐ **Customizable** scraping options to target specific data fields
- ⭐ **High** accuracy in capturing and organizing extracted data
- ⭐ Support for bulk data scraping from multiple **Zillow** listings
- ⭐ **Fast** and efficient performance for time-saving operations
- ⭐ Export data in various formats like CSV or JSON for easy integration
- ⭐ **Advanced** filtering to extract data based on specific criteria
- ⭐ **Secure** and compliant with data privacy regulations

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

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

1. ✅ **Sign up** or **log in** to the **Zillow** Email Scraper platform
2. ✅ Enter the URL of the **Zillow** listing or search page you want to scrape
3. ✅ **Select** the specific data fields you wish to extract such as emails or property details
4. ✅ **Configure** any filters or criteria to narrow down your scraping results
5. ✅ **Start** the scraping process and monitor the progress in real-time
6. ✅ Once completed review the extracted data for accuracy
7. ✅ **Export** the data to your preferred format such as CSV or JSON
8. ✅ Use the extracted data for your real estate marketing or lead generation activities

### Use Cases 🎯

Real Estate Lead Generation
🎯 Extract email addresses of property agents for targeted outreach
🎯 Build a comprehensive database of real estate leads from **Zillow**

Property Market Analysis
🎯 Gather property price and location data for market research
🎯 **Analyze** trends in real estate listings for investment opportunities

Agent and Agency Networking
🎯 Connect with real estate agents and agencies for collaboration
🎯 Access agent profiles to identify potential business partners

Marketing Campaigns
🎯 **Use** extracted email addresses for email marketing campaigns
🎯 Target specific property types or locations for personalized marketing

### Why choose us? 💎

**Zillow** Email Scraper is a **reliable** and efficient tool for extracting data from **Zillow** listings. It is designed to meet the needs of real estate professionals, offering a **user-friendly** interface and **advanced** features.

The tool ensures high accuracy and consistency in data extraction, saving users time and effort. By automating the process, it eliminates the need for manual data collection, allowing users to focus on their core business activities.

This real estate lead generation tool is customizable, enabling users to target specific data fields and apply filters. It supports bulk data scraping, making it ideal for large-scale projects.

With secure data handling and compliance with privacy regulations, **Zillow** Email Scraper is a trusted choice for real estate businesses. It is perfect for generating leads, analyzing market trends, and enhancing marketing efforts.

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

**Zillow** Email Scraper is designed to handle data extraction tasks of any scale. Whether you need to scrape a few listings or thousands, the tool performs **efficient**ly without compromising accuracy.

It supports bulk scraping, allowing users to extract data from multiple **Zillow** pages simultaneously. The tool is built with **advanced** algorithms to ensure fast and reliable performance, even for large datasets.

Users can customize their scraping tasks to target specific data fields or apply filters, making it adaptable to various project requirements. With its robust infrastructure, **Zillow** Email Scraper can scale to meet the demands of growing real estate businesses.

It is an ideal solution for professionals looking to automate and streamline their data collection processes.

### **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 when using the scraper
⚖️ **Use** the tool only for lawful and ethical purposes in real estate activities
⚖️ **Avoid** scraping personal data that is not publicly available on **Zillow**
⚖️ **Do not** use the scraper to send unsolicited emails or spam messages
⚖️ Respect data privacy regulations such as GDPR and CCPA when handling extracted data
⚖️ Limit scraping activities to avoid overloading **Zillow**s servers
⚖️ **Obtain** necessary permissions if required for specific data extraction tasks
⚖️ **Use** the extracted data responsibly and in compliance with applicable laws

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Zillow 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 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 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 **Email Scraper**?

Zillow Email Scraper is a tool designed to extract email addresses and other contact details from Zillow listings.

#### Who can use this tool?

Real estate agents, brokers, investors, and **businesses** can use this tool for lead generation and data collection.

#### What data can I **extract** with this scraper?

You can extract email addresses, phone numbers, agent names, property prices, locations, and more.

#### Is the tool user-friendly?

**Yes**, Zillow Email Scraper features a simple interface for easy data extraction.

#### Can I customize the data fields to scrape?

**Yes**, you can select specific data fields and apply filters to target your scraping results.

#### Is the data **extract**ion process fast?

**Yes**, the tool is optimized for fast and efficient data scraping.

#### Can I **export** the **extract**ed data?

**Yes**, you can export data in formats like **CSV** or **JSON** for easy integration.

#### Is the tool compliant with data privacy regulations?

**Yes**, Zillow Email Scraper is designed to comply with data privacy laws such as GDPR and CCPA.

#### Does the tool support bulk scraping?

**Yes**, it supports bulk data scraping from multiple Zillow listings.

#### What are the **legal** guidelines for using this tool?

Ensure **compliance** with Zillow's terms of service and use the tool for lawful and ethical purposes only.

#### Can I scrape agent profiles with this tool?

**Yes**, you can extract details from agent profiles, including email addresses and agency information.

#### Is technical support available?

**Yes**, technical support is available to assist with any issues or queries.

#### Can I use this tool for marketing campaigns?

**Yes**, the tool is ideal for collecting data for email marketing and targeted outreach.

#### Does the tool work for all Zillow listings?

The tool works for **publicly available** Zillow listings that comply with their terms of service.

#### How do I get started with the tool?

Sign up, input the Zillow URL, configure your settings, and start scraping to get started.

# 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("scraply/zillow-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("scraply/zillow-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 scraply/zillow-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow Email Scraper",
        "description": "📧 Zillow Email Scraper extracts real estate leads by pulling email addresses from Zillow listings. 🏡 Fast, accurate, and built for B2B prospecting, outreach, and market research. 🚀 Save time and boost conversions.",
        "version": "0.1",
        "x-build-id": "GzxdzlsW9HnJRDoku"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraply~zillow-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraply-zillow-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/scraply~zillow-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraply-zillow-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/scraply~zillow-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraply-zillow-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```