# Google Maps Email Scraper Unlimited (`scrapers-hub/google-maps-email-scraper-unlimited`) Actor

🔎 Google Maps Email Scraper Unlimited extracts business emails from Google Maps with high accuracy. Perfect for lead generation, sales outreach & B2B research. 🚀 Save time, boost prospecting. 📧 Start scraping effortlessly today!

- **URL**: https://apify.com/scrapers-hub/google-maps-email-scraper-unlimited.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **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

### Google Maps Email Scraper Unlimited 📬

**Google Maps Email Scraper Unlimited** is an Apify actor that searches for businesses in a chosen location and extracts their contact information—helping you build an email list for lead generation, outreach, and research. Whether you’re a marketer, recruiter, or data enthusiast looking for a **google maps email scraper unlimited** or a **google maps email extractor unlimited**, this actor automates the workflow of finding business listings and then harvesting emails, phone numbers, and social media profiles from publicly available sources—saving you hours of manual work.

---

### 🚀 Why choose Google Maps Email Scraper Unlimited?

| Feature | Benefit |
| --- | --- |
| ✅ **All-in-one lead building** | Finds businesses and extracts emails plus supporting contact details in one run |
| ✅ **Email-only results mode** | Lets you save only businesses where emails were successfully extracted (useful for a **google maps email list builder**) |
| ✅ **Proxy configuration support** | Enables proxy settings for more reliable large-scale scraping |
| ✅ **Resilient scraping flow** | Uses built-in retries and fallbacks for resilience during website processing |
| ✅ **Structured dataset output** | Pushes consistent records to the Apify dataset for easy export and analysis |
| ✅ **Designed for scale** | Stop at your target business count (up to 1000) and keep scraping iteratively in email-only mode |

---

### 🔑 Key features

- 🧭 **Business search by niche + location**: Use `query` (e.g., “dentists”) and `location` (e.g., “Miami, Florida”) to drive discovery
- 📧 **Email extraction from websites**: Scrapes business websites to collect `scraped_emails` and count `emails_found`
- 📞 **Phone extraction + social media extraction**: Also captures `scraped_phones` and `scraped_social_media` alongside emails
- ✅ **Email-only mode filtering**: When enabled, only saves businesses that end up with at least one extracted email (great for **extract emails from google maps unlimited** workflows)
- 🛡️ **Proxy configuration for web scraping**: Supports `proxyConfiguration` for more reliable scraping runs
- 🔄 **Includes retries and fallbacks**: Website scraping uses resilience logic to improve completion rates
- 💾 **Real-time dataset saving**: Pushes each business record to the Apify dataset immediately (reduces data loss risk)
- 📊 **Useful business metadata**: Includes ratings, reviews, address fields, coordinates (`lat`, `long`), and `place_id` for deduping

---

### 📝 Input

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

```json
{
  "query": "coffee shops",
  "location": "Miami, Florida",
  "maxBusinesses": 50,
  "emailOnlyResults": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `query` | Yes | Type of business to search for (for example, `coffee shops`, `dentists`, or `restaurants`). |
| `location` | Yes | Geographic location to search (for example, `Miami, Florida`, `New York City`, or `Los Angeles, CA`). |
| `maxBusinesses` | No | Target number of businesses to find (1–1000). The scraper stops when this target is reached. Default is `20`. |
| `emailOnlyResults` | No | If `true`, only include businesses where emails were successfully extracted from their websites. Default is `false`. |
| `proxyConfiguration` | No | Proxy settings for scraping. Using proxies helps avoid IP blocks and rate limits. In the UI schema, this includes `proxy support`. |

***

### 📦 Output

The actor saves each business record’s data into an Apify dataset (dataset title: **Businesses with Contact Information**) with the following JSON fields derived from what the actor pushes to the dataset.

```json
{
  "name": "Business Name",
  "website": "https://example.com",
  "phone": "Phone value",
  "full_address": "Street City State ZIP CountryCode",
  "city": "City",
  "state": "State",
  "zip": "ZIP",
  "country_code": "Country code",
  "scraped_emails": [
    {
      "email": "info@example.com",
      "confidence_score": 92.5,
      "validation_status": "valid",
      "source_url": "https://example.com/contact",
      "source_type": "body"
    }
  ],
  "scraped_phones": ["+1 555-123-4567"],
  "scraped_social_media": ["https://twitter.com/example"],
  "emails_found": 1,
  "pages_scraped": 3,
  "avg_rating": 4.6,
  "total_reviews": 128,
  "lat": 25.7617,
  "long": -80.1918,
  "place_id": "SomePlaceId",
  "scrape_status": "success"
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | Business name from the listing data. |
| `website` | string | The business website URL (used for email/phone/social extraction). |
| `phone` | string | Phone value from the listing data (before website scraping). |
| `full_address` | string | Combined address string built from street/city/state/zip/country code. |
| `city` | string | City name. |
| `state` | string | State/region. |
| `zip` | string | ZIP/postal code. |
| `country_code` | string | Country code associated with the listing address. |
| `scraped_emails` | array | Extracted emails from the business website(s). Each entry includes `email`, `confidence_score`, `validation_status`, `source_url`, and `source_type`. |
| `scraped_phones` | array | Phone numbers extracted while scraping the business website. |
| `scraped_social_media` | array | Social media profile links extracted from the business website. |
| `emails_found` | number | Number of extracted emails found for the business website. |
| `pages_scraped` | number | How many pages were processed for the website scraping job. |
| `avg_rating` | number | Average rating from the listing data. |
| `total_reviews` | number | Total number of reviews from the listing data. |
| `lat` | number | Latitude coordinate for the listing. |
| `long` | number | Longitude coordinate for the listing. |
| `place_id` | string | Unique place identifier used for deduplication within the run. |
| `scrape_status` | string | The scraping outcome status (for example: `success`, `failed`, `no_website`, or `error`). |

After the run, you can export the dataset from the Apify Console to formats like JSON and CSV for further processing in spreadsheets, CRMs, or analytics pipelines.

***

### 🧭 How to use Google Maps Email Scraper Unlimited (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 **Google Maps Email Scraper Unlimited** and open the actor page.

3. **Configure your input**
   In the **INPUT** section, enter:

   - `query`: what kind of business you want (e.g., `dentists`)
   - `location`: where to search (e.g., `Miami, Florida`)

   Optionally set:

   - `maxBusinesses` to control the target volume
   - `emailOnlyResults` to save only businesses with extracted emails
   - `proxyConfiguration.proxy support` for proxy-enabled scraping runs

4. **Run the actor**
   Click **Run** to start. You’ll see live logs showing progress while businesses are discovered and websites are processed.

5. **Monitor execution**
   During execution, the actor scrapes business listing data, then scrapes websites for contact information. It saves records to the dataset as it goes, so you don’t have to wait for the entire job to finish.

6. **Review results**
   Open the **OUTPUT** tab and open the dataset named **Businesses with Contact Information**.

7. **Export your data**
   Export to JSON/CSV as needed for your email outreach, lead scoring, enrichment, or research workflow.

No coding required—get accurate results in minutes with **Google Maps Email Scraper Unlimited**.

***

### 🚀 Advanced features & SEO optimization

- 🌐 **Engineered for “email from local business listings” workflows**: Works well for **scrape emails from local business listings** and **bulk email scraper google maps** use cases
- 🧠 **Email-only lead building**: Perfect when you want a smaller, higher-intent list—ideal for **unlimited leads google maps email** and **google maps contact email scraper** needs
- 🧰 **Built for structured downstream processing**: Consistent dataset fields like `scraped_emails`, `emails_found`, `pages_scraped`, and `scrape_status` make it easy to analyze and filter
- 🛡️ **Proxy-ready for reliability at scale**: Includes proxy configuration support for large runs like **google maps email scraping software** style pipelines
- 📑 **Detailed output completeness**: Captures not only emails but also `scraped_phones` and `scraped_social_media`, helping you enrich contacts beyond **google maps lead generation scraper** alone

***

### 📌 Best use cases

- 📈 **B2B marketers building outbound lists**: Generate a targeted email list from business listings in a specific city for faster campaign setup
- 🧠 **Sales teams enriching lead databases**: Automatically collect `scraped_emails`, website context, ratings, and review counts for prioritization
- 🔎 **Researchers doing local business contact mining**: Build a structured dataset of contacts and business metadata for analysis
- 🎯 **Recruiters and HR teams sourcing company contacts**: Identify office contacts and team-level outreach emails from publicly available websites
- 🧾 **Data analysts validating lead quality**: Use `emails_found`, `pages_scraped`, and `scrape_status` to understand coverage and reliability
- 💻 **Developers automating lead pipelines**: Feed dataset exports into CRMs or ETL jobs to support repeatable **google maps email extractor unlimited** workflows
- 🔁 **Growth teams running iterative list expansion**: Use `maxBusinesses` and email-only mode to manage volume, especially for **google maps email list builder** needs

***

### 🛠️ Technical specifications

- **Supported Input Formats**
  - ✅ Uses an Apify actor input JSON object with `query` and `location`
  - ✅ Optional controls for `maxBusinesses`, `emailOnlyResults`, and `proxyConfiguration`

- **Proxy Support**
  - ✅ `proxyConfiguration` with `proxy support` available in the actor input schema

- **Retry Mechanism**
  - ✅ Website scraping includes resilience logic with retries and fallbacks

- **Dataset Structure**
  - ✅ Dataset: **Business Contact Data** → **Businesses with Contact Information**
  - ✅ Output rows include: `name`, `website`, `scraped_emails`, `scraped_phones`, `scraped_social_media`, `emails_found`, `pages_scraped`, `scrape_status`, and business/location fields like `avg_rating`, `total_reviews`, `lat`, `long`, `place_id`

- **Rate Limits & Performance**
  - ⚠️ Performance varies depending on how many businesses you request and how many pages/contacts each site exposes

- **Limitations**
  - ❌ If a business has no website, the actor marks the record with `scrape_status` set accordingly (e.g., `no_website`) and there are no extracted emails to save
  - ⚠️ Email availability depends on what the business publishes on its website and publicly accessible pages

***

### ❓ FAQ

#### ✅ Does Google Maps Email Scraper Unlimited extract emails only from websites?

Yes. The actor discovers businesses first, then scrapes the `website` associated with each listing to extract emails and contact details. This is also why the `emailOnlyResults` option can filter to only businesses where emails were successfully extracted.

#### ✅ What does “email-only mode” do?

When `emailOnlyResults` is `true`, the actor only pushes businesses to the dataset if it finds at least one extracted email (`emails_found > 0`). This is useful for building higher-intent lists for **google maps email extractor unlimited** style lead generation.

#### ✅ How many businesses can I request?

You can set `maxBusinesses` (default `20`) with a range of 1–1000. The actor will stop once it reaches your target number of businesses.

#### 💻 Can I run this as part of an automated pipeline?

Yes. The actor writes structured results into an Apify dataset, which you can export and integrate with downstream tools (spreadsheets, CRMs, or analytics). This makes it a good fit for **data mining google maps emails** workflows.

#### 🛡️ Do you support proxies?

Yes. You can configure `proxyConfiguration` (including `proxy support`) to enable proxy settings that help improve reliability for larger scraping runs.

#### ❌ Will every business listing have an email?

No. Some businesses may not provide emails on their website (or may have no website at all). The dataset includes `scrape_status`, `emails_found`, and `scraped_emails` so you can filter results reliably.

#### 🧾 What contact fields are included besides emails?

Besides `scraped_emails`, the dataset includes `scraped_phones` and `scraped_social_media`, along with business metadata such as `avg_rating`, `total_reviews`, and address/location fields (`full_address`, `city`, `state`, `zip`, `lat`, `long`).

#### ⚖️ Is this tool for extracting personal data?

This actor works with publicly available business contact information. You’re responsible for complying with applicable laws and the platforms’ terms regarding data privacy and outreach practices.

***

### 🤝 Support & feature requests

If you’re using **Google Maps Email Scraper Unlimited** and want improvements, share your feedback—we use it to guide the roadmap.

- 💡 Feature Requests: Want enhancements like additional export formats, custom filtering, or CRM-friendly output? Tell us what you need (for example, improvements for building **map listings email scraper unlimited** datasets).
- 📧 Contact: Email us at **<dataforleads@gmail.com>**

Your feedback directly shapes how we improve this **google maps email scraping software** for real-world lead generation.

***

*If you want a most comprehensive, SEO-optimized way to build an email list from business listings, **Google Maps Email Scraper Unlimited** is built for scale and structured results.*

***

### Disclaimer

**This tool accesses publicly accessible sources only.** It does not access private profiles, authenticated data, or password-protected pages. It’s your responsibility to comply with applicable laws (including GDPR/CCPA where relevant), spam regulations, and the target websites’ terms of service.

If you need data removal, contact <dataforleads@gmail.com>. Please use this actor responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

## `query` (type: `string`):

Type of business to search for (e.g., 'coffee shops', 'dentists', 'restaurants')

## `location` (type: `string`):

Geographic location to search (e.g., 'Miami, Florida', 'New York City', 'Los Angeles, CA')

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

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

## `emailOnlyResults` (type: `boolean`):

Only include businesses where emails were successfully extracted from their websites

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

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

## Actor input object example

```json
{
  "query": "coffee shops",
  "location": "Miami, Florida",
  "maxBusinesses": 20,
  "emailOnlyResults": 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 = {
    "query": "coffee shops",
    "location": "Miami, Florida",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/google-maps-email-scraper-unlimited").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 = {
    "query": "coffee shops",
    "location": "Miami, Florida",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/google-maps-email-scraper-unlimited").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 '{
  "query": "coffee shops",
  "location": "Miami, Florida",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapers-hub/google-maps-email-scraper-unlimited --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Email Scraper Unlimited",
        "description": "🔎 Google Maps Email Scraper Unlimited extracts business emails from Google Maps with high accuracy. Perfect for lead generation, sales outreach & B2B research. 🚀 Save time, boost prospecting. 📧 Start scraping effortlessly today!",
        "version": "1.0",
        "x-build-id": "u6GqC63QfvPaDBZl5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~google-maps-email-scraper-unlimited/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-google-maps-email-scraper-unlimited",
                "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~google-maps-email-scraper-unlimited/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-google-maps-email-scraper-unlimited",
                "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~google-maps-email-scraper-unlimited/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-google-maps-email-scraper-unlimited",
                "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": [
                    "location",
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Query",
                        "type": "string",
                        "description": "Type of business to search for (e.g., 'coffee shops', 'dentists', 'restaurants')",
                        "default": "coffee shops"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Geographic location to search (e.g., 'Miami, Florida', 'New York City', 'Los Angeles, CA')",
                        "default": "Miami, Florida"
                    },
                    "maxBusinesses": {
                        "title": "Maximum Businesses",
                        "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": 20
                    },
                    "emailOnlyResults": {
                        "title": "Show Businesses with Email Only",
                        "type": "boolean",
                        "description": "Only include businesses where emails were successfully extracted from their websites",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
