# Architects Email Scraper (`scrapers-hub/architects-email-scraper`) Actor

🏗️ Architects Email Scraper finds architects’ direct email addresses from public web sources. ⚡ Boost B2B prospecting for firms, contractors & leads—faster outreach, cleaner lists, higher response. 🔎 Ideal for sales & recruitment.

- **URL**: https://apify.com/scrapers-hub/architects-email-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### Architects Email Scraper 🔍

**Architects Email Scraper** is a targeted email scraping tool that searches for architecture and design-related businesses in specific locations and extracts their contact information—especially email addresses—alongside phone numbers and social media profiles. If you’re looking for an **architects email scraper**, an **email scraper for architects**, or **architects contact email finder** to power **AEC email scraping tool** workflows, this actor helps you collect structured contact data faster than manual outreach research.

Whether you’re a marketer, data analyst, researcher, or BD professional, Architects Email Scraper is built for **targeted email scraping for architecture leads**—helping you turn city-level searches into usable email lists at scale.

---

### 🚀 Why choose Architects Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ All-in-one contact extraction | Extracts business contact information including emails, phone numbers, and social media profiles in one run |
| ✅ Built-in resilience | Includes fallbacks and resilience so you get results more reliably on real web pages |
| ✅ Proxy configuration support | Helps with large-scale scraping by letting you configure proxy settings for web fetching |
| ✅ Structured, tabular dataset output | Saves results in a dataset with consistent fields like `name`, `website`, addresses, and scraped contact arrays |
| ✅ Scale controls | Lets you set limits like **Maximum Businesses With Emails** (stop when the target is reached) |
| ✅ Real-time dataset saving | Pushes results to the Apify dataset as it goes, reducing risk of losing data during long runs |

---

### 🔑 Key features

- 🧭 **Location-based searching for architecture leads**: Use your city list to focus on where you want architects and architecture firms
- 📧 **Email extraction for architectural businesses**: Extracts emails from publicly available business websites
- 📞 **Phone number discovery**: Also extracts phone numbers to complement your outreach dataset
- 🔗 **Social media link collection**: Extracts social media profiles alongside email and phone contacts
- 🛡️ **Proxy-ready scraping**: Supports `proxyConfiguration` (recommended for larger batches) to improve reliability
- 💾 **Live dataset saving**: Pushes each email result to the Apify dataset immediately (flattened per email)
- 📊 **Progress-friendly limits**: Stops when your **Maximum Businesses With Emails** target is reached

---

### 📝 Input

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

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

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `googleMapsSearchTerm` | Yes | The business type or niche you want to search for (defaults to `"Architects"`). |
| `googleMapsLocation` | Yes | One or more target locations (for example: `"Miami, Florida"`). Provide it as an array of strings. |
| `maxBusinesses` | No | Target number of businesses to find with emails (range `1-1000`). The run stops once the target is reached. Default is `5`. |
| `scrapeMaxBusinessesPerLocation` | No | If `true`, it aims to collect up to `maxBusinesses` results per location. If `false`, it combines locations into a single total limit. Default is `false`. |
| `proxyConfiguration` | No | Proxy settings for scraping. This is recommended for large-scale scraping and is configured via Apify proxy support. |

• `proxyConfiguration.proxy support` (inside `proxyConfiguration`) | No | Whether to use Apify Proxy (prefilled as `true`). |

***

### 📦 Output

After execution, the actor saves each result into the Apify dataset (flattened per email when emails are found). Each row includes business details and the specific email that was found.

Example dataset row:

```json
{
  "name": "Unknown",
  "website": "https://example.com",
  "phone": "",
  "full_address": "123 Main St New York NY 10001 US",
  "city": "New York",
  "state": "NY",
  "zip": "10001",
  "country_code": "US",
  "scraped_emails": [],
  "scraped_phones": [],
  "scraped_social_media": [],
  "emails_found": 0,
  "pages_scraped": 0,
  "avg_rating": null,
  "total_reviews": null,
  "lat": null,
  "long": null,
  "place_id": null,
  "scrape_status": "no_website",
  "email_found": ""
}
```

> Note: When emails are found, the actor pushes **one row per extracted email**. In those rows, it includes `email_found` and does not include `scraped_emails` or `_detailed_emails`.

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | Business name |
| `website` | string | Business website URL |
| `phone` | string | Business phone number (as scraped from the business listing) |
| `full_address` | string | Full formatted address |
| `city` | string | City |
| `state` | string | State |
| `zip` | string | ZIP/postal code |
| `country_code` | string | Country code |
| `scraped_emails` | array | List of scraped emails from the business website (present in non-flattened business pushes / no-email scenarios) |
| `scraped_phones` | array | List of phone numbers found on the website |
| `scraped_social_media` | array | List of social media links found on the website |
| `emails_found` | number | Count of emails found for the business |
| `pages_scraped` | number | Number of processed URLs/pages during website scraping |
| `avg_rating` | number | Average rating value from the business listing (when available) |
| `total_reviews` | number | Total reviews value from the business listing (when available) |
| `lat` | number | Latitude |
| `long` | number | Longitude |
| `place_id` | string | Place identifier from the business listing |
| `scrape_status` | string | Scrape status (e.g., `success`, `failed`, `no_website`, `error`) |
| `email_found` | string | The single email value for flattened per-email rows, or `""` for cases with no emails pushed |

***

### 🧭 How to use Architects Email Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and open the **Actors** page.

2. **Find the actor**\
   Search for **Architects Email Scraper** and open its actor page.

3. **Configure your INPUT**\
   In the input panel, fill:
   - `googleMapsSearchTerm` (default is `"Architects"`)
   - `googleMapsLocation` as an array (e.g., `["New York"]`)
     Optionally set:
   - `maxBusinesses`
   - `scrapeMaxBusinessesPerLocation`
   - `proxyConfiguration.proxy support`

4. **Choose proxy settings (optional but recommended for scale)**\
   If you’re running large batches, enable `proxyConfiguration` so the actor can scrape more reliably.

5. **Click Run**\
   Start the run and monitor the live logs to see progress and results as they’re discovered.

6. **Open the OUTPUT dataset**\
   After completion, open the dataset (Business Contact Data view) and inspect rows.

7. **Export your results**\
   Export in JSON/CSV from the dataset UI and load into your CRM, spreadsheet, or analysis pipeline.

No coding required—get architects email lists in minutes.

***

### ⚙️ Advanced features & SEO optimization

- 🧠 **Keyword-focused extraction for architects lead generation**: Built for architecture-firm email extraction workflows using your provided business type/niche and location targets.
- 🌐 **Directory-style business contact enrichment**: Works as a practical **architect directory email scraper** approach—collecting website contacts plus `scraped_phones` and `scraped_social_media`.
- 💾 **Flattened per-email rows**: When emails are found, results are saved row-by-row with `email_found`, making it easier to deduplicate and import.
- 🛡️ **Proxy configuration for dependable scraping**: Includes `proxyConfiguration` support for better performance at scale.
- 📌 **Limits to keep runs predictable**: The actor stops based on your `maxBusinesses` and the per-location strategy you choose via `scrapeMaxBusinessesPerLocation`.

***

### 🎯 Best use cases

- 📈 **Marketing teams building targeted outreach**: Generate an **architects email list scraper** style dataset per city for campaigns and sequences
- 🏗️ **Business development for architecture firms**: Find and **find architecture firm emails** to reach decision-makers faster
- 🔬 **Data analysts enriching AEC datasets**: Combine contact emails with structured fields like rating, address, and coordinates for downstream modeling
- 🧾 **Recruiters and research roles**: Build a structured list of architecture providers and their public contact endpoints
- 🤝 **Sales ops and CRM admins**: Import flattened rows (with `email_found`) to power lead scoring and segmentation
- 🗺️ **Agencies running location-based prospecting**: Use `googleMapsLocation` to create **residential architecture email scraper** or **commercial architect email scraper** style lists by region
- 💻 **Automation pipelines**: Schedule runs and push enriched contact info into BI dashboards or outreach tooling

***

### 🔧 Technical specifications

- **Supported Input Formats**
  - ✅ `googleMapsSearchTerm` as a string (defaults to `"Architects"`)
  - ✅ `googleMapsLocation` as an array of strings
  - ✅ Optional limits: `maxBusinesses`, `scrapeMaxBusinessesPerLocation`
  - ✅ Optional proxy configuration via `proxyConfiguration`

- **Proxy Support**
  - ✅ Configurable with `proxyConfiguration` (Apify proxy support via `proxy support`)

- **Retry Mechanism**
  - ✅ Includes retries and fallbacks for resilience (configured at runtime via the actor’s scraping behavior)

- **Dataset Structure**
  - ✅ Apify dataset “Business Contact Data” with table fields such as `name`, `website`, `scraped_emails`, `emails_found`, `pages_scraped`, and `scrape_status`
  - ✅ Flattened per email rows include `email_found`

- **Rate Limits & Performance**
  - ✅ Concurrency and performance are optimized internally for faster website scraping across domains
  - ✅ Run stops when your `maxBusinesses` target is met

- **Limitations**
  - ❌ Businesses without an available website may be saved without scraped contact data (status reflects `no_website`)
  - ❌ If a business provides no publicly discoverable email contact on its website, `emails_found` may be `0`

***

### ❓ FAQ

#### What does the Architects Email Scraper extract?

✅ It searches for architecture-related businesses in your chosen locations and extracts contact information from their websites, including email addresses, phone numbers (`scraped_phones`), and social media profiles (`scraped_social_media`). It also saves business listing details like `name`, `website`, and address fields.

#### How do I get more results across multiple locations?

Use `googleMapsLocation` with multiple entries and set `scrapeMaxBusinessesPerLocation`:
if it’s `true`, the actor aims for up to `maxBusinesses` per location; if it’s `false`, it combines all locations into a single total limit.

#### Does it save results even if emails are not found?

✅ Yes—when `email_only_results` is effectively not enabled for your run, the actor can push businesses even with empty email results. Rows will show `scrape_status` such as `no_website`, and `email_found` will be `""` when applicable.

#### What fields will I see in the dataset?

✅ The dataset view includes fields like `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`, and `scrape_status`—plus `email_found` for flattened per-email rows.

#### Can I validate emails for higher confidence?

✅ The website scraping phase includes a `validate_emails` setting controlled in the actor input logic (internally derived from input). When validation is enabled, it checks emails during scraping.

#### Do I need to set proxy configuration?

❌ Not required for small runs, but ✅ recommended for larger-scale scraping. You can configure proxy behavior via `proxyConfiguration` and `proxy support`.

#### Is this tool legal and compliant to use?

✅ The actor collects information only from **publicly accessible sources**. It’s your responsibility to comply with applicable laws and regulations (including GDPR/CCPA) and with the terms of service of the sources you are scraping.

#### Can I contact you about data removal?

If you have data removal requests, contact <dataforleads@gmail.com>.

***

### 🤝 Support & feature requests

Want to improve Architects Email Scraper for architects lead generation and targeted email scraping for architecture leads? 💡

- 💡 **Feature Requests**: For example, adding more export-friendly shaping for bulk email extractor for architects workflows (CSV options, more dataset flattening controls, or additional fields).
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for this architects email scraper for architects and AEC lead workflows.

***

### *Architects Email Scraper* — get architects email lists at scale

*If you’re after the most comprehensive, SEO-optimized architects contact email finder workflow, run Architects Email Scraper and move from city searches to ready-to-use outreach data fast.*

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

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/architects-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": "Architects",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Architects Email Scraper",
        "description": "🏗️ Architects Email Scraper finds architects’ direct email addresses from public web sources. ⚡ Boost B2B prospecting for firms, contractors & leads—faster outreach, cleaner lists, higher response. 🔎 Ideal for sales & recruitment.",
        "version": "1.0",
        "x-build-id": "jXyBPsThjyb1675uc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~architects-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-architects-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/scrapers-hub~architects-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-architects-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/scrapers-hub~architects-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-architects-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": "Architects"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
