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

Zillow Email Scraper extracts publicly available email addresses from Zillow property and agent listings. Build targeted real estate lead lists by location and property type. Ideal for brokers, marketers, and investors needing scalable contact data.

- **URL**: https://apify.com/scraper-engine/zillow-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Automation, Jobs
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

The **Zillow** Email Scraper allows users to **extract** a wide range of **data** from **Zillow** property listings. This includes **contact** information, property details, and other essential **data** points for real estate professionals.

By automating the **data** **extract**ion process, the tool ensures accuracy and efficiency. Users can gather **emails**, phone numbers, and other relevant information to streamline their lead generation efforts.

The scraper is designed to handle large-scale **data** **extract**ion while maintaining **data** integrity. It is perfect for real estate agents, marketers, and investors looking to enhance their outreach strategies.

With its user-friendly interface, the **Zillow** Email Scraper makes **data** collection easy and effective.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com *

### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract email addresses associated with property listings for direct communication. |
| Phone Numbers | Gather phone numbers of property owners or agents for quick contact. |
| Property Addresses | Retrieve full property addresses for location-based insights. |
| Listing Prices | Collect the listed prices of properties for market analysis. |
| Agent Information | Extract details about real estate agents, including names and contact info. |
| Property Descriptions | Scrape detailed descriptions of properties for better understanding. |
| Images | Download property images for visual reference and marketing purposes. |
| Property Features | Retrieve data on property features such as size, number of rooms, and amenities. |

### Key Features of **Zillow** Email Scraper

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

- ⭐ **Automated** email scraping from **Zillow** property listings
- ⭐ Extracts multiple data types including contact details and property information
- ⭐ User-friendly interface for easy operation and data management
- ⭐ Supports large-scale data extraction for extensive lead generation
- ⭐ Provides accurate and organized data for seamless integration into workflows
- ⭐ **Customizable** scraping options to target specific data points
- ⭐ **Secure** and reliable ensuring data privacy and compliance
- ⭐ **Regular** updates to ensure compatibility with **Zillow**s platform
- ⭐ **Fast** data processing to save time and improve efficiency
- ⭐ Export data in multiple formats for easy analysis and sharing

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

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

1. ✅ **Sign up** or **log in** to the **Zillow** Email Scraper platform
2. ✅ Enter the specific **Zillow** URL or search criteria for the listings you want to scrape
3. ✅ Customize the data points you wish to extract such as emails or property details
4. ✅ Set any filters or preferences such as location or price range for targeted scraping
5. ✅ **Start** the scraping process and monitor the progress through the dashboard
6. ✅ Once completed review the extracted data for accuracy and completeness
7. ✅ **Export** the data in your preferred format such as CSV or Excel
8. ✅ Use the extracted information for lead generation marketing or analysis

### Use Cases 🎯

Real Estate Lead Generation
🎯 Extract contact emails of property owners and agents for outreach
🎯 Build a database of potential clients for real estate services

Market Analysis
🎯 Gather property prices and features for competitive analysis
🎯 Track market trends by analyzing data from multiple listings

Marketing Campaigns
🎯 **Use** extracted emails for targeted email marketing campaigns
🎯 Enhance direct marketing efforts with accurate contact data

Investor Insights
🎯 **Identify** potential investment opportunities by analyzing property data
🎯 Access detailed property descriptions to evaluate investment potential

Agent Networking
🎯 Connect with real estate agents for collaboration opportunities
🎯 Expand your professional network using agent contact details

### Why choose us? 💎

Our **Zillow** Email Scraper stands out as a **reliable** and efficient tool for extracting data from **Zillow**. With **advanced** automation, it eliminates the need for manual data collection, saving you time and effort.

The scraper is designed to handle large-scale data extraction while maintaining accuracy and organization. It supports a wide range of data points, including emails, phone numbers, and property details, making it a versatile solution for real estate professionals.

Our tool is **user-friendly** and customizable, allowing you to tailor the scraping process to your specific needs. Regular updates ensure compatibility with **Zillow**'s platform, providing a seamless experience.

We prioritize data security and compliance, ensuring that your data extraction activities are ethical and safe. Whether you're a real estate agent, marketer, or investor, our **Zillow** Email Scraper is the perfect solution for your lead generation and data collection needs.

### **Zillow** Email Scraper Scalability 📈

The **Zillow** Email Scraper is built to handle projects of all sizes, from small-scale data collection to enterprise-level lead generation. Its **advanced** algorithms ensure fast and **efficient** data processing, even for large datasets.

The tool can extract data from thousands of **Zillow** listings in a single session without compromising accuracy. It is designed to adapt to the growing needs of businesses, making it a scalable solution for real estate professionals.

Whether you're targeting a specific neighborhood or a nationwide market, the scraper can handle the workload. With **customizable** settings, you can focus on the data points that matter most to your business.

Our robust infrastructure ensures that the tool performs reliably, even under heavy usage. This makes it an ideal choice for businesses looking to scale their data extraction efforts.

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

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Zillow**s terms of service when using the scraper
⚖️ **Do not** use the scraper for unauthorized or malicious purposes
⚖️ **Avoid** sharing or selling extracted data without proper consent
⚖️ Respect privacy laws and regulations in your region when handling data
⚖️ **Use** the scraper only for legitimate business purposes such as lead generation
⚖️ **Do not** scrape data from listings marked as private or restricted
⚖️ Regularly review and adhere to updates in **Zillow**s policies
⚖️ **Ensure** that your use of the scraper aligns with ethical data practices

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

### Output Format 📤

📝 Example Output (JSON)

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

### 🔗 What other Zillow scraping tools are there?

If you want to scrape specific Zillow data, you can use any of the dedicated scrapers below for faster and more targeted results.\
Just enter search keywords, listing URLs, or company names and start scraping instantly.

| [☎️ Zillow Phone Number Scraper](https://apify.com/scraper-engine/zillow-phone-number-scraper) | [🔎 Zillow Search Scraper](https://apify.com/scraper-engine/zillow-search-scraper) |
|---|---|
| [📧 Zillow B2B Email Scraper](https://apify.com/scraper-engine/zillow-b2b-email-scraper) | [📞 Zillow B2B Phone Number Scraper](https://apify.com/scraper-engine/zillow-b2b-phone-number-scraper) |

### FAQ ❓

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

The Zillow Email Scraper is a tool designed to extract contact information and other data from Zillow property listings efficiently.

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

You can extract **emails**, phone numbers, property addresses, listing prices, agent information, and more.

#### Is the scraper compatible with all Zillow listings?

The scraper works with most Zillow listings, but it may not access private or restricted data.

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

**Yes**, the scraper allows you to customize data points and apply filters for targeted scraping.

#### Is the tool user-friendly?

**Yes**, the Zillow Email Scraper features a simple interface for easy operation.

#### How do I **export** the **extract**ed data?

You can export the data in formats like **CSV** or Excel for further use.

# Actor input Schema

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

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

# API

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

## JavaScript example

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

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

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

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

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

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

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

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

```

## CLI example

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow Email Scraper",
        "description": "Zillow Email Scraper extracts publicly available email addresses from Zillow property and agent listings. Build targeted real estate lead lists by location and property type. Ideal for brokers, marketers, and investors needing scalable contact data.",
        "version": "0.1",
        "x-build-id": "9RjKibybWvDaeDlUZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~zillow-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-zillow-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scraper-engine~zillow-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-zillow-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scraper-engine~zillow-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-zillow-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Zillow (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Zillow profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Zillow"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Zillow"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```