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

📧 Zillow Email Scraper extracts seller & property contact emails from Zillow listings. Fast, accurate data capture for real estate lead gen, outreach, and market research. 🚀 Automate your prospecting—save time, boost ROI.

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

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Zillow Email Scraper 🎯

Manually visiting hundreds of profiles to collect emails wastes hours you don’t have. **Zillow Email Scraper** helps you scrape emails from Zillow profiles using your chosen keywords and email-domain filters—so you can build a Zillow email list faster. This **Zillow email scraper** (and **Zillow scraper email**) is ideal for marketers, recruiters, and growth teams who want outreach-ready contacts at scale. In a single run, you can collect up to thousands of email opportunities—depending on your inputs and limits.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "network": "Zillow.com",
  "keyword": "founder",
  "title": "John Doe — Founder at Acme Realty",
  "description": "Contact: john.doe@gmail.com | Marketing & brokerage",
  "url": "https://www.zillow.com/profile/john-doe/",
  "email": "john.doe@gmail.com",
  "proxyGroups": [
    "my-proxy-group"
  ]
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network for the lead record (set to `Zillow.com`). |
| `keyword` | string | The keyword that helped find this contact, useful for segmentation and testing outreach angles. |
| `title` | string | The page/result title tied to the email—helps you understand context fast. |
| `description` | string | The surrounding text where the email was detected (great for validation and notes). |
| `url` | string | The Zillow page link for the record, so you can verify and reference the lead. |
| `email` | string | The extracted email address that you can add to outreach workflows. |
| `proxyGroups` | array | Proxy configuration reference used during the run (useful for debugging and transparency). |

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

***

### Why Zillow Email Scraper?

There are a lot of ways to pull data from Zillow—here’s what sets Zillow Email Scraper (including a “Zillow email list” workflow and a “Zillow outreach email list” approach) apart.

#### Targeted keyword + domain filtering

You provide your own `keywords` and `customDomains` so the actor focuses on email addresses that match your outreach preferences. This makes the Zillow property email finder use case feel much more controlled than generic scraping.

#### Lead-ready structured output

Each result is pushed as a consistent JSON record containing the extracted `email`, plus helpful context like `title`, `description`, and `url`. That’s exactly what you need when you’re building a Zillow agent leads email list for outreach or CRM import.

#### Resilience for long runs

The actor includes stop conditions and safeguards so large searches don’t run forever. It also uses retries/fallback behavior internally to keep scraping stable when results are sparse or requests fail.

#### Run-time control with a hard email cap

Use `maxEmails` to stop once enough results are collected. This helps manage cost and runtime while testing different versions of your Zillow email scraper strategy.

***

### Configuring Your Run

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

```json
{
  "keywords": ["founder", "marketing"],
  "location": "San Diego, CA",
  "platform": "Zillow",
  "customDomains": ["@gmail.com", "@company.com"],
  "maxEmails": 50,
  "engine": "legacy",
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `keywords` | ✅ | A list of keywords to search for. The scraper uses them to find relevant Zillow profile bios/posts and extract matching emails. |
| `location` | ⬜ | Location to filter search results. Leave it empty to search without a location filter. |
| `platform` | ⬜ | Select platform. This actor supports `Zillow`. |
| `customDomains` | ⬜ | List of custom email domains to target (for example, `@gmail.com`). Helps you get the right type of leads. |
| `maxEmails` | ⬜ | Maximum number of emails to collect. The actor stops once this limit is reached (it doesn’t guarantee hitting the number). |
| `engine` | ⬜ | Choose scraping engine. Options are `cost-effective` (faster/cheaper approach) or `legacy` (more reliable but slower/expensive). |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor (supports Apify Proxy configuration UI/options). |

***

### Core Capabilities

#### Keyword-based lead discovery for Zillow profiles

Zillow Email Scraper uses your `keywords` to focus the search on Zillow profile bios and posts that relate to what you’re looking for. If you’re trying to scrape Zillow emails for a specific niche, this keeps results relevant.

#### Domain-targeted email extraction

Using `customDomains`, the actor extracts emails that match the domains you care about. This is ideal when you need a Zillow contact email scraper that can prioritize personal domains (like Gmail) or specific corporate domains.

#### Pagination + stop controls for predictable runs

The actor paginates through results and stops when it reaches your `maxEmails` limit. This gives you predictable runtime behavior when building a Zillow email list for campaigns and outreach.

#### Built for bulk collection at controlled scale

You can run it with multiple keywords and collect results in batches until the limit is reached. It’s a practical Zillow lead scraper for generating a Zillow agent email scraper output you can work with immediately.

#### Structured dataset output you can export right away

Every extracted email is pushed to the Apify dataset along with context fields like `title`, `description`, and `url`. That means your Zillow property email email finder output is ready for downstream enrichment and segmentation.

***

### Who Gets the Most Out of This

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

**Marketing Teams** — Use it to scrape Zillow emails relevant to their campaign niche, then create a segmented Zillow outreach email list by keyword and email domain. This shortens the time from lead discovery to sending outreach.

**Recruiters & Talent Sourcers** — Extract emails tied to Zillow bios where keyword matches appear, then build a targeted list for networking and recruiting campaigns. The `url` field helps validate quickly before outreach.

**Sales Development Representatives** — Turn a prospect list into actionable contacts by extracting emails from publicly available Zillow profile content. The result is faster list building for cold email sequences and lead qualification.

**Real Estate Marketers** — Find emails associated with Zillow listings/profile descriptions using focused keywords and domain filters. This helps them compile a more relevant Zillow agent leads email dataset instead of broad, noisy scraping.

**Data Analysts & Researchers** — Create datasets for analysis by capturing contextual fields (`title`, `description`, `url`) alongside `email`. This is useful for studying lead distribution by keyword/domain and measuring outreach pool sizes.

**Automation & Integration Specialists** — Use the actor’s dataset output to feed CRMs and internal tooling via Apify automation workflows. The consistent JSON fields make it easier to map results into pipelines that power outreach and reporting.

***

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

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

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find **Zillow Email Scraper**.
2. **Enter your inputs** — set `keywords` (required) and optionally `location`, `customDomains`, `maxEmails`, `platform`, and `engine`.
3. **Configure proxy settings** — use the built-in proxy configuration options available in Run Options for reliability.
4. **Hit Run and watch the live log** — monitor progress in the Apify log output.
5. **View results in the dataset tab** — each extracted email record is pushed with context fields like `title`, `description`, and `url`.
6. **Export as JSON, CSV, or Excel** — download the dataset directly from the Apify dashboard.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

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

Export formats available from the dataset tab include **JSON**, **CSV**, and **Excel**. That makes it easy to move a Zillow email list into spreadsheets, BI tools, or manual review.

For automation, you can connect using Apify-compatible integration patterns such as Zapier/Make, and pull results via the **Apify API** ([apify.com/docs/api](https://apify.com/docs/api)). If you use webhooks in your stack, you can trigger downstream actions when the run completes.

***

### Pricing & Free Trial

Zillow Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. Apify typically uses pay-as-you-go billing based on compute usage (and supports subscription plans for heavier use). Start with a test run using a small `maxEmails` value to validate your keyword/domain filters, then scale when your outreach pool is ready.

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

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Large searches | Uses pagination with stop controls like `maxEmails` so you stay in bounds. |
| Reliability across runs | Supports proxy configuration to improve consistency for scraping at scale. |
| Sparse or blocked responses | Includes retry/fallback behavior internally to keep runs moving when results are limited. |
| Output usability | Pushes structured records immediately to your Apify dataset with context fields for verification and enrichment. |

**Limitations:** Results depend on what’s publicly available on Zillow profiles and what emails appear in the relevant bios/text. If there are few matching bios for your `keywords` and `customDomains`, you may see fewer results—try broader keywords or additional domains.

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

***

### Frequently Asked Questions

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

Yes. Apify offers a free tier so you can run Zillow Email Scraper without a credit card for initial testing. This is a good way to validate your `keywords` and `customDomains` before scaling.

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

No. Zillow Email Scraper is designed to work with publicly available web data, so you don’t need an account or login to run it.

#### How accurate is the data?

The extracted `email` values come from publicly available text where the actor detects matching email patterns based on your `customDomains`. Accuracy is therefore dependent on what the content actually contains—there’s no email guessing.

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

You can control the maximum number of extracted emails with `maxEmails`. The actor stops once it reaches that limit, and it won’t guarantee hitting the number if fewer matching emails exist.

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

The actor runs on demand. So “freshness” is tied to when you run the actor and what emails are publicly visible at that time.

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

You should treat this as a tool for collecting data from **publicly available data** that you can access without login. Compliance with GDPR, CCPA, and platform Terms of Service is your responsibility, especially for how you store and use the leads.

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

Yes. You can export from the Apify dataset tab as JSON, CSV, or Excel, then import into Google Sheets or another spreadsheet tool. For direct automation, you can also connect workflows using Apify-compatible integration options.

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

Yes. You can schedule actor runs on Apify so Zillow Email Scraper runs automatically at intervals you choose, based on your lead sourcing workflow.

#### Can I access this via API?

Yes. You can access results programmatically using the Apify API. See the API documentation at [apify.com/docs/api](https://apify.com/docs/api).

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

If an error occurs during scraping or data pushing, the actor continues operating with its designed retry/stop behaviors and pushes successful results as they’re found. You’ll also be able to review run logs to understand what happened.

***

### Need Help or Have a Request?

Got a question about Zillow Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We actively maintain this actor and can help with practical setup tips or requests like webhook notifications on completion and improved batch-friendly workflows.

***

### Disclaimer & Responsible Use

*Zillow Email Scraper is the fastest, most reliable way to build a Zillow outreach email list from publicly available sources — start your free run today.*

Data is collected from **publicly available data** on the web, and the actor does not access private profiles, login-gated content, or password-protected pages. You’re responsible for ensuring your usage complies with GDPR, CCPA, and applicable platform Terms of Service. 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": "Zillow",
  "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/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": [
        "founder",
        "marketing",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperoka/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 seller & property contact emails from Zillow listings. Fast, accurate data capture for real estate lead gen, outreach, and market research. 🚀 Automate your prospecting—save time, boost ROI.",
        "version": "0.0",
        "x-build-id": "RcbtLGr4fo1wnON5I"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~zillow-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-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/scraperoka~zillow-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-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/scraperoka~zillow-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-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": "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": [
                            "Zillow"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Zillow"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
