# Real Estate Agent Email Scraper (`solid-scraper/real-estate-agent-email-scraper`) Actor

🏡 Real Estate Agent Email Scraper extracts verified contact emails from targeted listings and agent profiles. Fast, accurate lead sourcing for real estate teams, agencies & investors—streamline outreach and grow your pipeline 📈

- **URL**: https://apify.com/solid-scraper/real-estate-agent-email-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Lead generation, Real estate, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

### Real Estate Agent Email Scraper 📬
**Real Estate Agent Email Scraper** helps you find and collect contact information for real estate businesses, including email addresses, phone numbers, and social media profiles—so you can build a real estate agent contact email list faster than manual research. Whether you’re searching for a **real estate email scraper**, **property agent email extractor**, or **real estate lead email scraper**, this tool is designed for marketers, data analysts, and researchers who want to extract publicly available contact details at scale while keeping results structured and usable.

---

### Why choose Real Estate Agent Email Scraper?

| Feature | Benefit |
|---|---|
| ✅ **All-in-one contact enrichment** | Extracts emails plus phone numbers and social media links from scraped websites |
| ✅ **Reliability with built-in proxy support** | Uses proxy settings for more stable large-scale scraping |
| ✅ **Resilient scraping flow** | Includes safeguards like fallbacks and stop conditions to keep runs efficient |
| ✅ **Structured dataset output** | Saves results to the Apify dataset in a predictable, table-friendly format |
| ✅ **Scale with limits** | Lets you target a maximum number of businesses with early stopping |
| ✅ **Immediate dataset saving** | Pushes results to the dataset during execution (including one row per found email) |

---

### Key features

- 🧠 **Real estate agent prospecting at scale**: Finds real estate business entries and prepares them for contact extraction  
- 🌐 **Website-first contact extraction**: Scrapes contact information from each business website (when available)  
- 📧 **Email-focused results**: Pushes one output row per email found (when emails are available)  
- 📞 **Phone and social media extraction**: Captures phone numbers and social media profiles when available from the domain data  
- 🛡️ **Proxy configuration support**: Works with provided proxy settings to improve scrape stability  
- 🔄 **Stop conditions and quota controls**: Uses maximum limits to stop once your target is reached  
- 💾 **Dataset-ready structure**: Outputs fields like `scraped_emails`, `scraped_phones`, `scraped_social_media`, plus summary stats  
- ⚙️ **Configurable validation**: Supports `validate_emails` to control whether extracted emails are validated  

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "googleMapsSearchTerm": "Real Estate Agent",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `googleMapsSearchTerm` | No | Business type or niche to target (prefilled as `Real Estate Agent`). |
| `googleMapsLocation` | Yes | Target geographic location(s) for the email scraper (example format: `New York`, or other city/region strings). |
| `maxBusinesses` | No | Target number of businesses to find (1–1000). The scraper stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | No | If enabled, the scraper collects up to `maxBusinesses` results per location; if disabled, it combines all locations up to a single total limit. |
| `proxyConfiguration` | No | Proxy settings for scraping (recommended for larger-scale runs). |

##### `proxyConfiguration` object fields

| Field | Required | Description |
|---|---:|---|
| `proxyConfiguration.proxy support` | No | When `true`, the actor uses Apify Proxy. Default prefill is `true`. |

> Note: While the input schema includes only the fields above, the actor also reads additional internal flags from input (e.g., email validation) when present.

***

### Output

After execution, the actor saves each business’s contact data in JSON format to the **Business Contact Data** dataset view.

#### What the dataset contains

The actor ultimately flattens outputs in **one row per found email** when `emails_found > 0` (it sets `email_found` and removes `scraped_emails` / `_detailed_emails` from the pushed row copy). If email-only mode is enabled, businesses without emails are not pushed.

Here is a realistic example of one dataset row:

```json
{
  "name": "Example Real Estate Office",
  "website": "https://example.com",
  "phone": "+1-555-0100",
  "full_address": "123 Main St New York NY 10001 US",
  "city": "New York",
  "state": "NY",
  "zip": "10001",
  "country_code": "US",
  "scraped_emails": [
    "agent@example.com",
    "sales@example.com"
  ],
  "scraped_phones": ["+1-555-0100"],
  "scraped_social_media": [
    "https://linkedin.com/company/example"
  ],
  "emails_found": 2,
  "pages_scraped": 3,
  "avg_rating": 4.6,
  "total_reviews": 128,
  "lat": 40.7128,
  "long": -74.006,
  "place_id": "ChIJ...",
  "scrape_status": "success",
  "email_found": "agent@example.com"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `name` | string | Business name |
| `website` | string | Website URL |
| `phone` | string | Phone number (as captured in the business listing stage) |
| `full_address` | string | Combined address string |
| `city` | string | City |
| `state` | string | State |
| `zip` | string | ZIP/postal code |
| `country_code` | string | Country code |
| `scraped_emails` | array | Emails found on the website (present on non-flattened business rows) |
| `scraped_phones` | array | Phone numbers found during website scraping |
| `scraped_social_media` | array | Social media profile links found during website scraping |
| `emails_found` | number | Count of emails found |
| `pages_scraped` | number | Number of processed URLs/pages scraped |
| `avg_rating` | number | Average rating (from listing data) |
| `total_reviews` | number | Total number of reviews (from listing data) |
| `lat` | number | Latitude |
| `long` | number | Longitude |
| `place_id` | string | Place identifier |
| `scrape_status` | string | Status such as `success`, `failed`, `no_website`, or `error` |
| `email_found` | string | Single email value for flattened rows (one row per email found) |

##### Missing-data behavior

If a business has no website, the actor sets:

- `scraped_emails` to `[]`
- `scraped_phones` to `[]`
- `scraped_social_media` to `[]`
- `emails_found` to `0`
- `pages_scraped` to `0`
- `scrape_status` to `no_website`

If email-only mode is enabled, businesses without emails may be excluded from pushes.

> After exporting, JSON is ready for downstream processing; many users also convert dataset rows to CSV for spreadsheets and CRMs.

***

### How to use Real Estate Agent Email Scraper (via Apify Console)

1. **Open Apify Console**\
   Go to [console.apify.com](https://console.apify.com) and log in.

2. **Find the actor**\
   Search for **Real Estate Agent Email Scraper** in the Actors tab.

3. **Fill in the required input**\
   Add your:
   - `googleMapsSearchTerm` (defaults to `Real Estate Agent`)
   - `googleMapsLocation` (required)

4. **Choose your limits**\
   Set `maxBusinesses` (1–1000) to control how many businesses you want results for.\
   If you have multiple locations, decide whether to enable `scrapeMaxBusinessesPerLocation`.

5. **(Optional) Configure proxies**\
   In `proxyConfiguration`, keep `proxy support` enabled for more stable scraping at scale.

6. **Run the actor**\
   Click **Run**. Watch logs to see scraping progress and website scraping steps.

7. **Review results in the dataset**\
   Open the **Business Contact Data** dataset view. You’ll see structured rows including contact fields and scrape status.

8. **Export the data**\
   Export JSON from Apify (or convert it to CSV in your workflow). You can then use it for lead lists, research, or enrichment pipelines.

No coding required—get real estate agent contact email data in minutes with this **Real Estate Agent Email Scraper**.

***

### Advanced features & SEO optimization

- 🏷️ **Built for “real estate lead email scraper” workflows**: Uses your `googleMapsSearchTerm` and target `googleMapsLocation` to focus results on the business niche you care about (e.g., real estate email scraper style outreach).
- 🧩 **Email-first dataset shaping**: When emails are found, the actor pushes one row per email via `email_found`, while preserving the rest of the business context fields for easier CRM import.
- 🧾 **Consistent data completeness signals**: Includes `emails_found`, `pages_scraped`, and `scrape_status` so you can quickly filter successes vs failures.
- 🛡️ **Proxy-ready for reliable scraping**: Supports proxy configuration through `proxyConfiguration` to help avoid interruptions during larger runs.
- 🔎 **Great fit for vertical variations**: Works well for “broker email list scraper” and similar needs where you’re **find real estate agent emails** and build a **real estate marketing email database**.

***

### Best use cases

- 📈 **Marketing teams building outreach lists**: Quickly generate a **real estate agent email prospecting** dataset for cold email campaigns
- 🧠 **Data analysts validating lead coverage**: Use `emails_found`, `pages_scraped`, and `scrape_status` to measure enrichment quality
- 🏘️ **Lead gen researchers mapping local inventory**: Compare contact coverage across `googleMapsLocation` values
- 📋 **CRM operations**: Import structured fields like `name`, `website`, `full_address`, `scraped_phones`, and `email_found`
- 💌 **Cold outreach practitioners**: Turn public web sources into a ready-to-use **scrape real estate agent contact emails** dataset
- 🧰 **Sales enablement**: Build a **real estate leads email scraping tool** workflow to keep prospect lists fresh
- 🧾 **Compliance-aware teams (internal use)**: Use the clear `scrape_status` and explicit contact fields to support documentation and review

***

### Technical specifications

- **Supported Input Formats** ✅\
  JSON input with these fields in `input.json`: `googleMapsSearchTerm`, `googleMapsLocation`, `maxBusinesses`, `scrapeMaxBusinessesPerLocation`, and `proxyConfiguration`.

- **Proxy Support** ✅\
  Uses `proxyConfiguration` (including `proxy support`) to improve scraping stability, especially for larger runs.

- **Retry Mechanism** ✅\
  The actor includes resilient scraping behavior with internal safeguards and stop conditions (configured via environment and scraping config logic).

- **Dataset Structure** ✅\
  Writes to the Apify dataset view **Businesses with Contact Information** with transformation fields including:\
  `name`, `website`, `phone`, `full_address`, `city`, `state`, `zip`, `country_code`, `scraped_emails`, `scraped_phones`, `scraped_social_media`, `emails_found`, `pages_scraped`, `avg_rating`, `total_reviews`, `lat`, `long`, `place_id`, `scrape_status`.

- **Rate Limits & Performance** ➕\
  Designed for controlled scraping runs using concurrency and request timing controls from configuration.

- **Limitations** ❌\
  If a business has no website (or no extractable contact info), the actor records empty arrays and `scrape_status` of `no_website` (and may omit pushes when email-only behavior is enabled).

***

### FAQ

#### What does the Real Estate Agent Email Scraper return?

✅ It returns a dataset where each business includes contact fields such as `scraped_emails`, `scraped_phones`, and `scraped_social_media`, along with summary metrics like `emails_found` and `pages_scraped`. When emails are found, the actor also uses `email_found` for flattened rows (one row per email).

#### Do I need to provide a location?

✅ Yes. `googleMapsLocation` is required in the input schema. You can pass one or more location strings.

#### How do I control how many businesses are collected?

✅ Use `maxBusinesses`. The actor stops when the target is reached. If you also enable `scrapeMaxBusinessesPerLocation`, it targets up to `maxBusinesses` per location instead of one combined global total.

#### Will it validate the emails?

✅ The actor supports `validate_emails` behavior via input (e.g., `validateEmails` if provided in your run input). If enabled, it validates extracted emails using its internal validation configuration.

#### Does it extract phone numbers and social media too?

✅ Yes. For businesses with a website, it populates `scraped_phones` and `scraped_social_media` from domain-level extracted data.

#### What happens when a business has no website?

❌ It will set `scraped_emails` / `scraped_phones` / `scraped_social_media` to empty arrays, sets `emails_found` to `0`, `pages_scraped` to `0`, and `scrape_status` to `no_website`. Depending on email-only behavior, such businesses may not be pushed.

#### Can I use this for real estate marketing email database building?

✅ Yes. This **real estate marketing email database** workflow is one of the primary intended uses—especially when you want **real estate agent contact info scraper** results that are easy to export and load into your systems.

#### Is there an API requirement?

✅ No. This actor is designed to run through Apify Console with `input.json`. If you integrate with Apify via your own pipeline, you can still treat the dataset export as your output.

***

### Support & feature requests

If you want to improve this **Real Estate Agent Email Scraper**—or request a feature for your real estate email scraper workflow—share your idea with us.

- 💡 **Feature Requests**: For example, CSV exports tailored for CRM fields, more control over email normalization, or additional dataset formatting options.
- 📧 **Contact**: Email us at <dataforleads@gmail.com>.

Your feedback directly shapes the roadmap for this real estate lead email scraping tool.

***

### Real Estate Agent Email Scraper 📬

*With the Real Estate Agent Email Scraper, you can turn publicly available real estate contact signals into a clean, dataset-ready pipeline for outreach—without the manual busywork.*\
*Built for speed, structure, and scale, this is an SEO-optimized way to find real estate agent emails reliably.*

***

### Disclaimer

**This tool accesses publicly available sources** to help extract business contact information. It does not access private profiles, authenticated data, or password-protected pages.

You are responsible for complying with applicable laws and regulations (for example, GDPR and CCPA), as well as respecting each website’s Terms of Service. Always use scraped contact data responsibly and for legitimate purposes.

For data removal requests, contact <dataforleads@gmail.com>.

# Actor input Schema

## `googleMapsSearchTerm` (type: `string`):

Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').

## `googleMapsLocation` (type: `array`):

Target geographic location for the email scraper (e.g., 'Miami, Florida').

## `maxBusinesses` (type: `integer`):

Target number of businesses to find (1-1000). The scraper will stop when this target is reached.

## `scrapeMaxBusinessesPerLocation` (type: `boolean`):

If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.

## `proxyConfiguration` (type: `object`):

Proxy settings for scraping. Recommended for large-scale scraping.

## Actor input object example

```json
{
  "googleMapsSearchTerm": "Real Estate Agent",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "googleMapsSearchTerm": "Real Estate Agent",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/real-estate-agent-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 = {
    "googleMapsSearchTerm": "Real Estate Agent",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/real-estate-agent-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 '{
  "googleMapsSearchTerm": "Real Estate Agent",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call solid-scraper/real-estate-agent-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Real Estate Agent Email Scraper",
        "description": "🏡 Real Estate Agent Email Scraper extracts verified contact emails from targeted listings and agent profiles. Fast, accurate lead sourcing for real estate teams, agencies & investors—streamline outreach and grow your pipeline 📈",
        "version": "1.0",
        "x-build-id": "192bwVOprPHpGhf6q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~real-estate-agent-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-real-estate-agent-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/solid-scraper~real-estate-agent-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-real-estate-agent-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/solid-scraper~real-estate-agent-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-real-estate-agent-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": [
                    "googleMapsLocation",
                    "googleMapsSearchTerm"
                ],
                "properties": {
                    "googleMapsSearchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').",
                        "default": "Real Estate Agent"
                    },
                    "googleMapsLocation": {
                        "title": "Location",
                        "type": "array",
                        "description": "Target geographic location for the email scraper (e.g., 'Miami, Florida').",
                        "default": [
                            "New York"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxBusinesses": {
                        "title": "Maximum Businesses With Emails",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Target number of businesses to find (1-1000). The scraper will stop when this target is reached.",
                        "default": 5
                    },
                    "scrapeMaxBusinessesPerLocation": {
                        "title": "Scrape Max Businesses Per Location",
                        "type": "boolean",
                        "description": "If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for scraping. Recommended for large-scale scraping."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
