# Redfin Email Scraper (`scraper-engine/redfin-email-scraper`) Actor

Redfin Email Scraper extracts publicly available email addresses from Redfin property and agent listings. Build targeted real estate contact lists by city or listing type. Ideal for brokers, investors, and marketers running outreach campaigns.

- **URL**: https://apify.com/scraper-engine/redfin-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Real estate, Automation
- **Stats:** 5 total users, 1 monthly users, 100.0% runs succeeded, 1 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

### **Redfin** Email Scraper 📱

**Redfin** Email Scraper allows users to **extract** a wide range of **data** from **Redfin** listings to support real estate operations. This tool is capable of collecting **contact** information, property details, and other essential **data** points.

Users can retrieve seller and agent **emails**, phone numbers, and location-specific information. Additionally, it provides insights into property pricing, availability, and listing descriptions.

The **extract**ed **data** is structured and easy to integrate into CRM systems or marketing tools. **Redfin** Email Scraper is designed to ensure accuracy and relevance in the **data** collected, making it a valuable resource for professionals in the real estate industry.

Redfin Email Scraper is a powerful tool designed for extracting contact information from Redfin listings efficiently and accurately. It enables real estate professionals to streamline their lead generation process by automating data collection.

With Redfin Email Scraper, users can access valuable contact details and property data without manual effort. This tool is ideal for real estate agents, marketers, and investors looking to enhance their outreach strategies.

Redfin Email Scraper ensures compliance with legal and ethical standards while providing high-quality data extraction capabilities. It is built to handle large-scale scraping tasks seamlessly and reliably.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Seller Email | Extracts email addresses of property sellers listed on Redfin. |
| Agent Contact Information | Retrieves emails and phone numbers of real estate agents. |
| Property Address | Collects full property addresses for listed properties. |
| Listing Price | Extracts the price details of listed properties. |
| Property Description | Retrieves detailed descriptions of property listings. |
| Property Availability | Identifies whether a property is active, pending, or sold. |
| Location Data | Collects geographical data related to property listings. |
| Property Features | Extracts information about property features and amenities. |

### Key Features of **Redfin** Email Scraper

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

- ⭐ **Automated** extraction of seller and agent contact details from **Redfin** listings
- ⭐ Ability to retrieve detailed property descriptions and listing prices effortlessly
- ⭐ Supports bulk data scraping for large-scale lead generation campaigns
- ⭐ Provides structured and organized data for easy integration into CRM systems
- ⭐ Ensures accuracy and relevance in the extracted data for better decision-making
- ⭐ User-friendly interface suitable for both technical and non-technical users
- ⭐ **Advanced** filtering options to target specific properties or regions
- ⭐ Compliance with legal and ethical standards for data scraping
- ⭐ **High**-speed scraping capabilities for efficient data collection
- ⭐ **Customizable** settings to tailor the scraping process to specific needs

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

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

1. ✅ **Sign up** for an account and **log in** to the **Redfin** Email Scraper platform
2. ✅ Enter the specific criteria for the properties or contacts you wish to scrape
3. ✅ **Select** the data types you want to extract such as emails addresses or prices
4. ✅ **Configure** advanced filters to narrow down your search results if needed
5. ✅ **Start** the scraping process and monitor progress through the dashboard
6. ✅ Download the extracted data in your preferred format such as CSV or JSON
7. ✅ **Integrate** the data into your CRM or marketing tools for further use
8. ✅ Repeat the process as needed for updated or additional data

### Use Cases 🎯

Real Estate Lead Generation
🎯 Extract seller and agent contact information for outreach campaigns
🎯 **Collect** property data to identify potential investment opportunities

Market Analysis
🎯 Gather pricing and availability data for competitive market research
🎯 **Analyze** property features and descriptions to identify trends

CRM Integration
🎯 Import structured data into CRM systems for streamlined management
🎯 **Use** extracted data to enhance customer segmentation and targeting

Legal and Ethical Data Use
🎯 Ensure compliance with data scraping regulations and guidelines
🎯 Utilize extracted data responsibly for legitimate business purposes

### Why choose us? 💎

**Redfin** Email Scraper stands out as a **reliable** and efficient tool for real estate data extraction. It is designed to meet the needs of professionals seeking accurate and actionable insights.

Our platform combines **advanced** automation with **user-friendly** features to simplify the process of collecting critical information. We prioritize compliance with legal and ethical standards to ensure responsible data use.

With **Redfin** Email Scraper, users can save time and resources while accessing high-quality data for decision-making. Our tool supports scalability, making it suitable for both small-scale and large-scale operations.

Whether you're a real estate agent, marketer, or investor, **Redfin** Email Scraper is tailored to enhance your lead generation and market analysis efforts. We offer exceptional customer support and continuous updates to keep our tool aligned with industry needs.

### **Redfin** Email Scraper Scalability 📈

**Redfin** Email Scraper is built to handle data extraction tasks of any scale, making it suitable for individual professionals and large organizations. Its **advanced** automation features ensure **efficient** processing of large volumes of data without compromising accuracy.

Users can customize their scraping criteria to target specific regions, property types, or data points. The tool supports bulk data extraction, allowing users to collect information from thousands of listings in a single session.

**Redfin** Email Scraper is optimized for performance, ensuring fast and reliable results even during high-demand tasks. Whether you're managing a small portfolio or conducting **extensive** market research, our tool adapts to your needs **seamless**ly.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Redfin**s terms of service when using the scraper
⚖️ **Use** the tool only for legitimate business purposes such as lead generation or market analysis
⚖️ **Avoid** redistributing extracted data without proper authorization from **Redfin**
⚖️ **Do not** use the scraper for spamming or unsolicited marketing campaigns
⚖️ Respect privacy laws and regulations when handling contact information
⚖️ Limit the frequency of scraping to avoid overloading **Redfin**s servers
⚖️ **Ensure** transparency in your data usage policies to maintain ethical standards
⚖️ Consult legal professionals if unsure about the compliance requirements

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Redfin Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Redfin",
  "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 (Redfin) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Redfin",
    "keyword": "Redfin 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 Redfin as the source |
| keyword | Keyword that triggered the result (Redfin Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Redfin profile link |
| email | Extracted email address |

### FAQ ❓

#### What is Redfin **Email Scraper**?

Redfin Email Scraper is a tool designed to extract contact information and property data from Redfin listings for real estate professionals.

#### Is Redfin **Email Scraper** **legal**?

**Yes**, Redfin Email Scraper is legal when used in **compliance** with Redfin's terms of service and applicable data privacy laws.

#### What data can I **extract** using Redfin **Email Scraper**?

You can extract seller **emails**, agent contact information, property addresses, listing prices, descriptions, and availability data.

#### How do I integrate the **extract**ed data into my **CRM**?

The extracted data can be downloaded in formats like **CSV** or **JSON**, which are compatible with most CRM systems.

#### Can I scrape data from **specific** regions?

**Yes**, Redfin Email Scraper allows users to configure filters to target specific regions or property types.

#### Is the tool suitable for **large-scale** data **extract**ion?

**Yes**, Redfin Email Scraper is optimized for scalability and can handle bulk data extraction tasks efficiently.

#### How often can I use Redfin **Email Scraper**?

You can use the tool as often as needed, but ensure **compliance** with Redfin's server usage policies.

#### Does the tool provide real-time data updates?

Redfin Email Scraper extracts data based on the most recent listings available on Redfin at the time of scraping.

#### Is technical expertise required to use Redfin **Email Scraper**?

**No**, the tool is designed with a **user-friendly** interface suitable for both technical and non-technical users.

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

**Yes**, the tool offers customizable settings and filters to tailor the scraping process to your specific needs.

#### Does Redfin **Email Scraper** comply with privacy laws?

**Yes**, the tool is designed to ensure **compliance** with relevant privacy laws and ethical guidelines.

#### What formats are available for data **export**?

Extracted data can be exported in formats like **CSV** and **JSON** for easy integration and use.

#### How can I contact support for issues?

You can reach out to our customer support team through the contact options provided on our platform.

#### Are updates provided for the tool?

**Yes**, Redfin Email Scraper is regularly updated to align with industry standards and user needs.

#### Can I scrape data for multiple properties at once?

**Yes**, the tool supports bulk data scraping to extract information from multiple listings simultaneously.

# Actor input Schema

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

List of keywords to search for on Redfin (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Redfin 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": "Redfin",
  "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("scraper-engine/redfin-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("scraper-engine/redfin-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 scraper-engine/redfin-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Redfin Email Scraper",
        "description": "Redfin Email Scraper extracts publicly available email addresses from Redfin property and agent listings. Build targeted real estate contact lists by city or listing type. Ideal for brokers, investors, and marketers running outreach campaigns.",
        "version": "0.1",
        "x-build-id": "cTkn8dRgZgJB2ZwQ7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~redfin-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-redfin-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/scraper-engine~redfin-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-redfin-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/scraper-engine~redfin-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-redfin-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 Redfin (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Redfin profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Redfin"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Redfin"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```