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

- **URL**: https://apify.com/scrapapi/trulia-email-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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

### **Trulia** Email Scraper 📱

The **Trulia** Email Scraper allows users to **extract** a wide range of **data** from property listings on **Trulia**. This includes essential **contact** information such as email addresses, phone numbers, and agent details.

Additionally, the scraper can capture property-specific **data** like listing prices, property descriptions, and location details. The tool is designed to provide accurate and comprehensive **data** to support real estate professionals and businesses in their marketing and outreach efforts.

By automating the **data** **extract**ion process, the **Trulia** Email Scraper ensures that users can focus on leveraging the information to achieve their goals. It is a versatile solution for anyone involved in the real estate industry, offering valuable insights and **contact** details in a matter of minutes.

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

This real estate email scraper simplifies the process of collecting emails and other contact details from property listings on Trulia. It is ideal for real estate professionals, marketers, and businesses looking to connect with potential leads.

With the Trulia data extraction tool, you can save time and effort by automating the process of gathering contact information. It ensures accuracy and consistency in data collection for better decision-making.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract email addresses of property owners, agents, or brokers from Trulia listings. |
| Phone Numbers | Retrieve phone numbers associated with property listings for direct communication. |
| Agent/Broker Details | Collect names and contact information of real estate agents or brokers. |
| Property Prices | Capture the listed prices of properties for sale or rent on Trulia. |
| Property Descriptions | Extract detailed descriptions of properties, including features and amenities. |
| Location Information | Gather location data such as addresses, neighborhoods, and zip codes. |
| Listing URLs | Save links to property listings for future reference or analysis. |
| Images | Download property images included in the 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 email addresses and contact details from **Trulia** listings
- ⭐ Supports scraping of multiple data types including property prices and descriptions
- ⭐ User-friendly interface requiring no technical expertise to operate
- ⭐ **Customizable** scraping options to target specific property types or locations
- ⭐ **Fast** and efficient data extraction to save time and resources
- ⭐ Ensures data accuracy and consistency for reliable results
- ⭐ Compatible with various devices and operating systems for convenience
- ⭐ Offers export options to save extracted data in formats like CSV or JSON
- ⭐ Provides real-time data scraping for up-to-date information
- ⭐ Includes built-in error handling to manage potential scraping issues

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

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

1. ✅ **Sign up** for an Apify account or **log in** to your existing account
2. ✅ Search for the **Trulia** Email Scraper in the Apify Store
3. ✅ Click on the scraper and select Try for free or **Start** actor
4. ✅ **Input** your desired search criteria such as location or property type
5. ✅ Set any additional parameters like the number of listings to scrape
6. ✅ **Start** the scraper and monitor its progress in the Apify console
7. ✅ Download the extracted data once the scraping process is complete
8. ✅ **Export** the data in your preferred format such as CSV or JSON for further use

### Use Cases 🎯

Real Estate Lead Generation
🎯 **Use** the **Trulia** Email Scraper to collect contact details of potential buyers and sellers
🎯 Generate a list of real estate agents or brokers for networking and outreach

Market Analysis and Research
🎯 **Analyze** property prices and trends in specific locations using extracted data
🎯 **Study** property descriptions and features to understand market demands

Property Listing Management
🎯 Compile a database of property listings for internal use or client presentations
🎯 Track updates to property prices or availability with regular scraping

Real Estate Marketing
🎯 Create targeted email campaigns using the extracted contact information
🎯 **Identify** potential clients and send personalized marketing messages

### Why choose us? 💎

The **Trulia** Email Scraper is a **reliable** and efficient tool for extracting data from **Trulia**, tailored to meet the needs of real estate professionals and businesses. It simplifies the process of gathering contact information and property details, saving time and effort.

Our scraper is designed with user-friendliness in mind, ensuring that even non-technical users can operate it with ease. We prioritize data accuracy and provide customizable options to meet specific requirements.

With our tool, you can extract data in real-time and export it in various formats for seamless integration into your workflows. We also offer excellent customer support to assist you with any questions or issues.

Choose the **Trulia** Email Scraper for a dependable solution to your real estate data extraction needs, and take your lead generation and market analysis efforts to the next level.

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

The **Trulia** Email Scraper is built to handle data extraction tasks of any scale, making it suitable for both small businesses and large enterprises. It can process thousands of property listings **efficient**ly, ensuring that you receive the data you need without delays.

The tool is optimized for performance, allowing you to scrape data quickly and accurately, even during peak usage times. Whether you need to extract data from a single city or multiple regions, the scraper can accommodate your requirements.

Its robust architecture ensures that it can handle high volumes of data without compromising on quality or speed. With the **Trulia** Email Scraper, you can scale your data extraction efforts as your business grows, making it a versatile and future-proof solution.

### **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** compliance with **Trulia**s terms of service before using the scraper
⚖️ **Use** the extracted data only for lawful purposes such as lead generation or market research
⚖️ **Avoid** using the scraper for spamming or unsolicited marketing activities
⚖️ Respect the privacy of individuals by not sharing or selling their contact information without consent
⚖️ **Do not** scrape data that is restricted or protected by **Trulia**s platform policies
⚖️ Regularly review and adhere to local and international data protection laws such as GDPR or CCPA
⚖️ Limit the frequency of scraping to avoid overloading **Trulia**s servers
⚖️ **Use** the scraper responsibly to maintain ethical and professional standards

### 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 contact information and property details from Trulia's real estate platform.

#### Who can use the Trulia **Email Scraper**?

Real estate professionals, marketers, and **businesses** looking to generate leads or analyze market data can use this tool.

#### What types of data can I **extract**?

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

#### Is the scraper easy to use?

**Yes**, the scraper is **user-friendly** and requires no technical expertise to operate.

#### Can I customize the scraping parameters?

**Yes**, you can set specific criteria such as location, property type, or the number of listings to scrape.

#### In what formats can I **export** the data?

You can export the data in formats like **CSV** or **JSON** for easy integration into your workflows.

#### Is the scraper compatible with all devices?

**Yes**, the scraper is compatible with various devices and operating systems.

#### How often can I use the scraper?

You can use the scraper as often as needed, but ensure **compliance** with Trulia's terms of service.

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

**Yes**, the scraper is designed to handle high volumes of data efficiently.

#### Is the data **extract**ed accurate?

The scraper ensures data accuracy and consistency for reliable results.

#### Can I scrape data from multiple locations?

**Yes**, you can target multiple cities or regions for data extraction.

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

**Yes**, we offer customer support to assist you with any questions or issues.

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

**Yes**, as long as you comply with Trulia's terms of service and relevant data protection laws.

#### What should I do if I encounter errors?

The scraper includes built-in error handling, but you can also contact our support team for assistance.

#### Can I use the scraper for other real estate platforms?

**No**, this scraper is specifically designed for Trulia. For other platforms, check our Apify Store for additional tools.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trulia Email Scraper",
        "version": "0.1",
        "x-build-id": "kZdaiJ1G9kw5FUTMM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~trulia-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-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/scrapapi~trulia-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-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/scrapapi~trulia-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```