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

📧 Redfin Email Scraper extracts verified real estate agent emails from Redfin listings. Automate lead generation for B2B sales, marketing, and outreach—save time, improve targeting, and boost conversion with reliable data. 🚀

- **URL**: https://apify.com/scrapium/redfin-email-scraper.md
- **Developed by:** [Scrapium](https://apify.com/scrapium) (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 $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

### **Redfin** Email Scraper 📱

The **Redfin** Email Scraper allows users to **extract** a wide range of **data** from **Redfin**'s platform. This includes essential details such as email addresses, agent names, property information, and more.

By automating the **data** **extract**ion process, users can gather accurate and comprehensive **data**sets in a fraction of the time it would take manually. The tool is designed to ensure that all **extract**ed **data** is relevant and organized for easy analysis and use.

Whether you need **contact** details for real estate agents or property-specific information, this scraper provides a reliable solution. With its advanced capabilities, the **Redfin** Email Scraper is ideal for professionals in the real estate industry looking to optimize their workflows and improve lead generation efforts.

Redfin Email Scraper is a powerful tool designed to extract contact information from Redfin, one of the leading real estate platforms. It enables users to gather valuable data efficiently for real estate marketing and lead generation purposes.

With the Redfin Email Scraper, you can automate the process of collecting email addresses and other key details from real estate agents and property listings. This tool is perfect for professionals looking to streamline their data extraction efforts.

Redfin data extraction tools like this scraper are essential for businesses seeking to expand their outreach in the competitive real estate market. By automating data collection, you can save time and focus on closing deals.

### 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 real estate agents and property owners listed on Redfin. |
| Agent Names | Retrieve the names of real estate agents associated with property listings. |
| Property Details | Collect information about properties, including addresses, prices, and descriptions. |
| Phone Numbers | Extract phone numbers associated with agents or property listings. |
| Listing URLs | Gather direct links to property listings for further analysis. |
| Property Images | Download images associated with property listings for visual reference. |
| Agent Profiles | Retrieve detailed profiles of real estate agents, including their contact information. |
| Property Types | Identify the type of properties listed, such as residential, commercial, or rental units. |

### 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 email addresses and contact details from **Redfin**
- ⭐ User-friendly interface requiring no advanced technical skills
- ⭐ **Accurate** and organized data output for easy analysis
- ⭐ Capability to extract multiple data points such as property details and agent profiles
- ⭐ **Customizable** scraping parameters to target specific data sets
- ⭐ **Fast** and efficient data extraction saving time and effort
- ⭐ **Secure** and compliant with ethical data scraping practices
- ⭐ **Regular** updates to ensure compatibility with **Redfin**s platform
- ⭐ Support for large-scale data extraction projects
- ⭐ Detailed documentation and customer support for seamless usage

### 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 on the platform hosting the **Redfin** Email Scraper
2. ✅ Log in and navigate to the **Redfin** Email Scraper tool in the dashboard
3. ✅ Enter the specific search criteria or URLs you want to scrape from **Redfin**
4. ✅ **Configure** the scraping parameters such as data types and output format
5. ✅ **Start** the scraping process by clicking the Run button
6. ✅ Monitor the progress of the scraping task in real-time on the dashboard
7. ✅ Download the extracted data once the scraping process is complete
8. ✅ **Review** and organize the data as needed for your specific use case
9. ✅ If required repeat the process with different search criteria
10. ✅ Contact customer support for any assistance or troubleshooting

### Use Cases 🎯

Real Estate Lead Generation
🎯 **Collect** email addresses of real estate agents for targeted marketing campaigns
🎯 Gather contact details of property owners for direct outreach

Market Research
🎯 **Analyze** property trends by extracting data on listings and prices
🎯 **Study** agent profiles to understand market competition

Real Estate Investment
🎯 **Identify** potential investment opportunities by analyzing property details
🎯 Gather contact information for networking with agents and property owners

Marketing Campaigns
🎯 Create mailing lists using extracted email addresses and contact details
🎯 Enhance campaign targeting by analyzing property and agent data

### Why choose us? 💎

Our **Redfin** Email Scraper is designed with user convenience and efficiency in mind. We provide a **reliable** solution for extracting data from **Redfin**, ensuring that you get accurate and up-to-date information.

Our tool is **user-friendly**, making it accessible to professionals with varying levels of technical expertise. By automating the data extraction process, we save you time and effort, allowing you to focus on your core business activities.

Our scraper is equipped with **advanced** features, including customizable parameters and secure data handling, to meet the diverse needs of our users. Whether you're a real estate agent, marketer, or investor, our tool is tailored to help you achieve your goals.

With **regular** updates and dedicated customer support, we ensure a seamless experience for all our users. Choose our **Redfin** Email Scraper for a **reliable** and efficient data extraction solution that delivers results.

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

The **Redfin** Email Scraper is designed to handle data extraction tasks of any size, making it suitable for both small-scale and **large-scale** projects. Whether you need to scrape data for a single property or thousands of listings, our tool can accommodate your needs.

Our **advanced** infrastructure ensures that the scraper operates **efficient**ly even when handling large datasets. By offering **customizable** parameters, we allow users to tailor the scraping process to their specific requirements.

This scalability makes our tool ideal for businesses of all sizes, from individual professionals to large enterprises. With our **Redfin** Email Scraper, you can confidently scale your data extraction efforts without compromising on speed or accuracy.

### **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 scraper only for lawful purposes and avoid unauthorized data usage
⚖️ Respect privacy laws and regulations when handling extracted data
⚖️ **Do not** sell or distribute extracted data without proper permissions
⚖️ **Avoid** overloading **Redfin**s servers by adhering to ethical scraping practices
⚖️ **Use** the tool responsibly to prevent any disruption to **Redfin**s platform
⚖️ Regularly review legal updates related to data scraping and adjust usage accordingly
⚖️ Consult legal professionals if unsure about the legality of your data scraping activities

### 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 the Redfin **Email Scraper**?

The Redfin Email Scraper is a tool designed to extract email addresses and other data from Redfin's platform.

#### Who can use this tool?

The tool is suitable for real estate agents, marketers, investors, and other professionals seeking Redfin data.

#### Is the scraper easy to use?

**Yes**, the scraper features a **user-friendly** interface that requires no advanced technical skills.

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

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

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

**Yes**, the tool automates the entire data extraction process for efficiency.

#### Can I customize the scraping parameters?

**Yes**, the scraper allows you to configure parameters such as data types and output formats.

#### Is the tool compliant with **legal** guidelines?

The tool is designed to support ethical and lawful data scraping practices.

#### Does the scraper support **large-scale** data **extract**ion?

**Yes**, the scraper is scalable and can handle both small and large datasets.

#### How often is the tool updated?

The scraper is regularly updated to ensure compatibility with Redfin's platform.

#### What output formats are supported?

The extracted data can be downloaded in formats such as **CSV** or **JSON**.

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

**Yes**, we provide dedicated customer support to assist with any issues or questions.

#### Can I use the scraper on multiple devices?

**Yes**, the scraper can be accessed from multiple devices with your account credentials.

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

Simply sign up, log in, and follow the step-by-step instructions to begin scraping.

#### Is there a free trial available?

Check our website for information on free trials or demo versions of the tool.

#### What happens if I encounter an issue?

Contact our customer support team for assistance with any technical or usage issues.

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapium/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 verified real estate agent emails from Redfin listings. Automate lead generation for B2B sales, marketing, and outreach—save time, improve targeting, and boost conversion with reliable data. 🚀",
        "version": "0.1",
        "x-build-id": "eU6o7nL3EzieyJQXG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapium~redfin-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapium-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/scrapium~redfin-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapium-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/scrapium~redfin-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapium-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```