# Trulia Email Scraper (`scrapio/trulia-email-scraper`) Actor

Trulia Email Scraper helps you collect agent and property-related emails directly from Trulia listings. Use the data for partnerships, deal sourcing, and client outreach. Fast, scalable scraping with clean, export-ready results.

- **URL**: https://apify.com/scrapio/trulia-email-scraper.md
- **Developed by:** [Scrapio](https://apify.com/scrapio) (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

$14.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

### **Trulia** Email Scraper 📱

The **Trulia** Email Scraper allows users to **extract** a wide range of **data** from **Trulia** property listings. This includes essential **contact** details and property-specific information that can be used for lead generation and market analysis.

The tool is designed to handle large volumes of **data** efficiently, ensuring accuracy and relevance. Users can **extract** **emails**, property descriptions, pricing information, and more.

This real estate email scraper is perfect for professionals seeking to automate **data** collection processes. With its advanced capabilities, the **Trulia** Email Scraper ensures that you get structured and actionable **data** for your business needs.

Whether you are looking to target potential buyers or analyze market trends, this tool provides the necessary **data** in a streamlined manner.

Trulia Email Scraper is a powerful tool designed to extract contact information and property-related data from Trulia. It simplifies the process of gathering real estate leads for professionals and businesses.

With the Trulia Email Scraper, you can automate the extraction of emails and other critical data from property listings. This tool is ideal for real estate agents, marketers, and data analysts looking to streamline lead generation.

The Trulia Email Scraper ensures accurate and efficient data collection, saving you time and effort. It is a reliable solution for accessing structured information from Trulia’s vast database of property listings.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.scrapio@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract email addresses of property owners or agents listed on Trulia. |
| Property Titles | Retrieve the titles or names of properties listed on Trulia. |
| Pricing Information | Collect detailed pricing data for listed properties. |
| Property Descriptions | Extract detailed descriptions of properties, including features and amenities. |
| Agent Contact Details | Gather phone numbers and other contact details of real estate agents. |
| Location Information | Retrieve property locations, including addresses and zip codes. |
| Listing URLs | Collect URLs of individual property listings for direct access. |
| Property Images | Download images associated with property listings for visual reference. |

### Key Features of **Trulia** Email Scraper

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

- ⭐ Automates the extraction of emails and contact details from **Trulia** listings
- ⭐ Supports bulk data scraping for large-scale real estate lead generation
- ⭐ Provides highly accurate and structured data for analysis and outreach
- ⭐ **Customizable** scraping options to target specific property types or locations
- ⭐ User-friendly interface suitable for both beginners and advanced users
- ⭐ Ensures compliance with legal and ethical guidelines for data scraping
- ⭐ Offers fast and efficient data extraction saving time and resources
- ⭐ Compatible with various export formats for seamless data integration
- ⭐ Includes advanced filtering options to refine data collection results
- ⭐ **Regular** updates ensure compatibility with **Trulia**s platform changes
- ⭐ Provides detailed logs and error reporting for troubleshooting purposes
- ⭐ Cloud-based functionality allows for scalable and remote data scraping

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

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

1. ✅ **Sign up** for an account on the platform hosting the **Trulia** Email Scraper
2. ✅ Log in and navigate to the **Trulia** Email Scraper tool dashboard
3. ✅ Enter the search parameters such as location property type or price range
4. ✅ **Configure** the scraping settings including data types and export format
5. ✅ **Start** the scraper and allow it to process the data from **Trulia** listings
6. ✅ Monitor the scraping progress through the dashboard in real-time
7. ✅ Once completed download the extracted data in your preferred format
8. ✅ **Review** the data for accuracy and integrate it into your workflow
9. ✅ Use the data to generate leads or analyze market trends effectively
10. ✅ Adjust the scraper settings for future use based on your requirements
11. ✅ Contact support if you encounter any issues during the scraping process
12. ✅ Regularly update the scraper to ensure compatibility with **Trulia**

### Use Cases 🎯

Real Estate Lead Generation
🎯 Extract email addresses of property owners or agents for outreach
🎯 Build a database of potential clients for marketing campaigns

Market Analysis
🎯 **Analyze** pricing trends across different locations and property types
🎯 Gather data on property features and amenities for comparison

Property Listings Management
🎯 Monitor competitor listings to stay ahead in the market
🎯 Update your property database with the latest information from **Trulia**

Real Estate Investment Research
🎯 **Identify** potential investment opportunities in specific areas
🎯 Evaluate property details and pricing to make informed decisions

### Why choose us? 💎

Our **Trulia** Email Scraper is a **reliable** and efficient tool for real estate professionals and businesses. It simplifies the process of extracting valuable data from **Trulia**, allowing you to focus on lead generation and market analysis.

With **advanced** features and customizable options, this real estate scraping software is designed to meet your specific needs. Our tool ensures high accuracy and compliance with legal guidelines, giving you peace of mind while collecting data.

We provide **regular** updates to maintain compatibility with **Trulia**’s platform and ensure optimal performance. Our dedicated support team is always available to assist you with any questions or issues.

By choosing our **Trulia** Email Scraper, you gain access to a powerful solution that saves time, enhances productivity, and provides actionable insights for your business. Whether you are a real estate agent, marketer, or data analyst, our tool is tailored to help you achieve your goals efficiently.

Trust our expertise and experience to deliver the **best** results for your data extraction needs.

### **Trulia** Email Scraper Scalability 📈

The **Trulia** Email Scraper is designed to handle data extraction tasks of all sizes. Whether you need to scrape a few listings or thousands, our tool can scale to meet your requirements.

Its cloud-based functionality ensures that you can perform scraping tasks remotely and **efficient**ly. The tool supports bulk data extraction, making it ideal for **large-scale** real estate lead generation campaigns.

With **advanced** filtering options, you can target specific data points, ensuring relevance and accuracy. Our scraper is optimized for speed and performance, allowing you to process large datasets without delays.

Regular updates and maintenance ensure that the tool remains compatible with **Trulia**’s platform, even as it evolves. Whether you are a small business or a large enterprise, the **Trulia** Email Scraper provides the scalability and flexibility needed to support your data extraction needs.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** that you comply with **Trulia**s terms of service when using the scraper
⚖️ **Use** the **Trulia** Email Scraper only for lawful and ethical purposes
⚖️ **Avoid** using the scraper to collect data for spamming or unsolicited marketing
⚖️ **Do not** sell or distribute the extracted data without proper authorization
⚖️ Respect user privacy and avoid collecting sensitive personal information
⚖️ Verify the accuracy of the data before using it for business purposes
⚖️ Regularly review and adhere to local and international data protection laws
⚖️ Seek legal advice if you are unsure about the legality of your data scraping activities

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

### Output Format 📤

📝 Example Output (JSON)

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

### FAQ ❓

#### What is the Trulia **Email Scraper**?

The Trulia Email Scraper is a tool designed to extract **emails** and property-related data from Trulia for lead generation and market analysis.

#### Can I use the Trulia **Email Scraper** for bulk data **extract**ion?

**Yes**, the Trulia Email Scraper supports bulk data extraction for large-scale real estate campaigns.

#### Is the Trulia **Email Scraper** easy to use?

**Yes**, the tool features a **user-friendly** interface suitable for both beginners and advanced users.

#### What data can I **extract** using the Trulia **Email Scraper**?

You can extract **emails**, property titles, pricing information, descriptions, agent contact details, and more.

#### Is the Trulia **Email Scraper** compliant with **legal** guidelines?

**Yes**, the scraper is designed to comply with legal and ethical data scraping practices.

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

**Yes**, the scraper offers customizable options to target specific data points and property types.

#### Does the Trulia **Email Scraper** support data **export**?

**Yes**, you can export the extracted data in various formats for easy integration.

#### How often is the Trulia **Email Scraper** updated?

The tool is regularly updated to ensure compatibility with Trulia’s platform and optimal performance.

#### Can I use the Trulia **Email Scraper** for market analysis?

**Yes**, the scraper is ideal for analyzing property trends, pricing, and other market data.

#### Is there **customer support** available for the Trulia **Email Scraper**?

**Yes**, our **dedicated support** team is available to assist you with any questions or issues.

#### Can I use the Trulia **Email Scraper** on multiple devices?

**Yes**, the scraper is cloud-based, allowing you to access it from multiple devices.

#### What is the pricing for the Trulia **Email Scraper**?

Please refer to our pricing page for detailed information on the cost of the Trulia Email Scraper.

#### Is the Trulia **Email Scraper** suitable for small businesses?

**Yes**, the scraper is designed to be scalable and flexible, making it suitable for **businesses** of all sizes.

#### Can I scrape images using the Trulia **Email Scraper**?

**Yes**, the scraper allows you to download property images for visual reference.

#### Does the Trulia **Email Scraper** provide data filtering options?

**Yes**, the tool includes advanced **filtering** options to refine your data collection results.

# Actor input Schema

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

List of keywords to search for on Trulia (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Trulia 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": "Trulia",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

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

## JavaScript example

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

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

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

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

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

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

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

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

```

## CLI example

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trulia Email Scraper",
        "description": "Trulia Email Scraper helps you collect agent and property-related emails directly from Trulia listings. Use the data for partnerships, deal sourcing, and client outreach. Fast, scalable scraping with clean, export-ready results.",
        "version": "0.1",
        "x-build-id": "5vnZjywx9a5fee8xC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapio~trulia-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapio-trulia-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapio~trulia-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapio-trulia-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapio~trulia-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapio-trulia-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 Trulia (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Trulia profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Trulia"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Trulia"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```