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

📧 Extract emails from Google Maps listings with Google Maps Email Scraper Unlimited. Save time on lead research, boost outreach, and streamline B2B prospecting with accurate, targeted contacts. 🚀 Perfect for sales & marketing teams!

- **URL**: https://apify.com/scrapeflux/google-maps-email-scraper-unlimited.md
- **Developed by:** [ScrapeFlux](https://apify.com/scrapeflux) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 1 total users, 0 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 ⚡

If you’re trying to build an **unlimited Google Maps email scraper** pipeline, manually hunting for business contact details quickly turns into an endless spreadsheet chore. **Google Maps Email Scraper Unlimited** automates the process by scraping business listings and extracting their contact information (including emails) from publicly available web pages. It’s a great fit for **unlimited Google Maps leads email** workflows and helps teams create a **Google Maps email list builder** without the copy-paste grind. This is built for outreach teams, lead generation specialists, and researchers who need large volumes of business contacts fast. In a single run, you can pull up to your target number of businesses (and then scrape contact details from their websites) with results saved immediately as the actor progresses.  

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
{
  "name": "Bright Smile Dental Clinic",
  "website": "https://brightsmiledental.com",
  "phone": "+1 (305) 555-0199",
  "full_address": "2101 Ocean Dr Miami FL 33139 US",
  "city": "Miami",
  "state": "FL",
  "zip": "33139",
  "country_code": "US",
  "scraped_emails": [
    {
      "email": "contact@brightsmiledental.com",
      "confidence_score": 92.4,
      "validation_status": "valid",
      "source_url": "https://brightsmiledental.com/contact",
      "source_type": "contact_page"
    }
  ],
  "scraped_phones": ["+1-305-555-0199"],
  "scraped_social_media": ["https://www.facebook.com/brightsmileclinic"],
  "emails_found": 1,
  "pages_scraped": 7,
  "avg_rating": 4.6,
  "total_reviews": 238,
  "lat": 25.7617,
  "long": -80.1918,
  "place_id": "ChIJrwe3w0pZwokRj7kKq4v2b1k",
  "scrape_status": "success"
}
````

| Output field | Type | What It Tells You |
|---|---|---|
| `name` | string | The business name you can match to CRM records and outreach lists. |
| `website` | string | The business website used for contact extraction (when available). |
| `phone` | string | The phone number associated with the business listing. |
| `full_address` | string | A single formatted address string for easier deduping and geodata enrichment. |
| `city` | string | City for segmentation (campaigns by geography, local targeting, reporting). |
| `state` | string | State/province field for region-level filtering and lead routing. |
| `zip` | string | ZIP/postal code for accurate local lead lists. |
| `country_code` | string | Country code to keep international lists clean and standardized. |
| `scraped_emails` | array | The extracted emails found on the business website(s), including confidence and source details. |
| `scraped_phones` | array | Phone numbers found during website scraping, useful when listings differ from the site. |
| `scraped_social_media` | array | Social links found during website scraping (handy for multi-channel outreach). |
| `emails_found` | number | Quick count so you can filter, sort, or compute outreach readiness. |
| `pages_scraped` | number | How many pages were processed for contact extraction per business. |
| `avg_rating` | number | Rating score from the business listing, useful as a quality signal. |
| `total_reviews` | number | Review count for additional credibility scoring in your lead ranking. |
| `lat` | number | Latitude for mapping, clustering, and geo-based analysis. |
| `long` | number | Longitude for mapping, clustering, and geo-based analysis. |
| `place_id` | string | Unique place identifier to support deduplication across runs. |
| `scrape_status` | string | The final state for the business (for example: `success`, `no_website`, `failed`, `error`). |

Export your full dataset as JSON, CSV, or Excel from the Apify dashboard.

***

### Setting It Up

Drop this into your `input.json` and you're ready to go:

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

| Parameter | Required | What It Does |
|---|---|---|
| `query` | ✅ | The type of business to search for (for example, `dentists`, `restaurants`, or `coffee shops`). |
| `location` | ✅ | The geographic location to search (for example, `Miami, Florida`, `New York City`, or `Los Angeles, CA`). |
| `maxBusinesses` | ⬜ | Sets the target number of businesses to find (1–1000). The run stops when this target is reached. |
| `emailOnlyResults` | ⬜ | When enabled, saves only businesses where emails were successfully extracted from their websites. |
| `proxyConfiguration` | ⬜ | Proxy settings for scraping (recommended for larger runs). |
| ↳ `proxy support` | ⬜ | When set to `true`, routes requests through Apify Proxy for better reliability. |

***

### What It Does

Google Maps Email Scraper Unlimited searches for businesses in your chosen location and business type, then scrapes contact information from publicly available websites and writes everything to your Apify dataset as it goes.

#### Extract Google Maps contact leads in bulk

You provide a `query` and a `location`, and the actor collects businesses up to your `maxBusinesses` target. This makes it practical for building an **unlimited Google Maps leads email** workflow without manual browsing.

#### Scrapes emails, phones, and social links from websites

For each business with an available website, the actor extracts emails and also captures phone numbers and social media profiles found during website scraping. That means you can create a **google maps business email scraper** dataset that’s more outreach-ready than email-only lists.

#### Optional email-only filtering for cleaner outreach lists

If you set `emailOnlyResults` to `true`, only businesses with successfully extracted emails are saved. This is useful when you’re running a **bulk email scraper for google maps** and want fewer low-yield rows.

#### Clean, structured output saved immediately

Each business result is pushed to the dataset as it’s processed, with fields like `scraped_emails`, `emails_found`, `pages_scraped`, and `scrape_status`. You get consistent output that’s easy to load into spreadsheets, CRMs, or analysis tools—great for a **maps email extraction tool** workflow.

#### Built-in proxy support for reliable scraping

Proxy support is available via `proxyConfiguration`, including the `proxy support` setting. This helps keep long-running scraping jobs stable, which is exactly what you want from an **unlimited google maps leads email** tool.

Overall, Google Maps Email Scraper Unlimited helps you turn public business listings into a structured contact dataset with minimal effort.

***

### Why Google Maps Email Scraper Unlimited?

There are plenty of ways to pull data from mapping directories—here’s why **Google Maps Email Scraper Unlimited** stands out.

#### Designed for “unlimited” lead building workflows

Instead of forcing you into tiny batches, this actor is built around a target-based approach (`maxBusinesses`) and can continue scraping in **email-only mode** until it reaches your requested number of businesses with emails. That’s what makes it a strong **unlimited email scraping software** choice for sustained outreach ops.

#### Website-focused contact extraction (not just listing data)

You get a richer dataset by extracting emails from the business websites the actor discovers, along with `scraped_phones` and `scraped_social_media`. This is closer to what outreach teams actually need for **find business emails on google maps** and follow-up.

#### Cleaner results when you enable email-only saving

With `emailOnlyResults`, you can avoid saving businesses that didn’t yield emails from their websites. That keeps your **google maps email list builder** outputs more actionable—especially for high-volume campaigns or **google maps lead generation email scraper** pipelines.

***

### Real-World Use Cases

Here's how different teams put Google Maps Email Scraper Unlimited to work:

**Sales Development Representatives**\
A B2B SDR team needs real contact details for local service businesses. They run Google Maps Email Scraper Unlimited for their target `query` and `location`, then export the dataset to prioritize companies with `emails_found` > 0, speeding up outreach list creation from hours to minutes.

**Marketing Agencies**\
An agency managing multiple local SEO and lead-gen clients needs structured lead lists for each niche. They use the **google maps contact email extractor** output fields to segment by `city`, `state`, and review metrics (`avg_rating`, `total_reviews`), then deliver clean files per client campaign.

**Restaurant Lead Generation**\
A campaign manager wants to contact restaurants in a specific metro area for partnerships. By using a restaurant-focused `query` and enabling `emailOnlyResults`, they build a higher-yield **restaurant email scraper google maps** list where emails were successfully extracted from websites.

**Real Estate Teams**\
A real estate team needs leads from neighborhood-specific businesses (e.g., agencies, inspectors, and related services). They scrape and export data enriched with `place_id`, address fields (`full_address`, `zip`, `country_code`), and coordinates (`lat`, `long`) for map-based planning and reporting.

**Data Analysts and Automation Specialists**\
An analyst needs repeatable datasets for research or lead scoring models. They pull outputs for a `query` across locations, then use the consistent schema (`scraped_emails`, `pages_scraped`, `scrape_status`) to compute conversion-ready metrics and track scrape performance over time in a pipeline.

***

### How to Run It

No code required. Here's how to get your first results in under 5 minutes:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open **Google Maps Email Scraper Unlimited**.
2. **Enter your inputs** — set `query` and `location` (required), and optionally set `maxBusinesses` and `emailOnlyResults`.
3. **Configure proxy settings** (optional but recommended) — enable `proxyConfiguration` with `proxy support` for smoother large-scale runs.
4. **Start the run** — launch it and watch the live log for progress as businesses are processed.
5. **Open the Dataset tab** — results appear as the actor pushes each business record.
6. **Export your data** — download from Apify as JSON, CSV, or Excel.
7. **Use the dataset in your workflow** — load it into your CRM, spreadsheet, or analysis notebook.

The whole setup takes under 5 minutes — results start appearing within seconds of launch.

***

### Export & Integration Options

Once your data is collected, **Google Maps Email Scraper Unlimited** fits directly into your existing workflow.

Export your dataset from the Apify dashboard in the format you need. You can download your results as JSON, CSV, or Excel, using the Apify dataset tab.

For automation, you can connect with integrations like Zapier/Make, or trigger the actor via the Apify API to pull results programmatically. If you want downstream actions (like saving to a database or notifying a Slack channel), use Apify’s API/webhook-based approach as described in Apify documentation.

***

### Pricing

Google Maps Email Scraper Unlimited runs on Apify, which includes a **free tier** — no credit card needed to start. Free tier credit is typically enough for several real test runs, so you can validate that the **google maps email harvesting tool** output matches your lead strategy. For larger workflows, you’ll pay based on Actor compute unit (CU) usage without a monthly lock-in. For details on current plans and usage, check the Apify pricing page, then scale up when your results are ready to productionize.

Start free at [apify.com](https://apify.com) — scale up when you need to.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Web and listing variability | Collects businesses and then scrapes contact info from their websites when available. |
| Output quality filtering | `emailOnlyResults` lets you save only businesses where emails were successfully extracted. |
| Long-run stability | Proxy support is available via `proxyConfiguration` for more reliable scraping. |
| Operational transparency | Each business includes `scrape_status` so you can identify `success`, `no_website`, `failed`, or `error` outcomes. |

Limitations: the actor relies on publicly available websites for extracting `scraped_emails`. If a business listing has no website or the website doesn’t expose extractable email addresses, you may see `no_website` or an empty `scraped_emails` array. For cases that require custom handling for edge cases or specific data quality rules, we can help configure an approach.

For enterprise-scale needs or custom configurations, reach out and we'll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes. Apify provides a free tier with usage credits so you can test Google Maps Email Scraper Unlimited before scaling up to larger **unlimited google maps leads email** workloads.

#### Do I need to log in or create an account on Google Maps?

No. The actor works using data from publicly available sources and doesn’t require you to provide a login for access.

#### How accurate is the extracted data?

Accuracy depends on what the business publishes on its website. The actor extracts emails, phones, and social media links from the websites it processes and outputs confidence and validation-related fields inside `scraped_emails` (plus counts like `emails_found`) so you can judge reliability.

#### How many results can I get per run?

You control the business target using `maxBusinesses` (1–1000). The actor stops when it reaches the target in normal mode, and in email-only mode it continues until it collects enough businesses with extracted emails.

#### How fresh is the data?

Freshness depends on how recently the underlying public pages and websites changed. The run captures data at the time it scrapes; for the most up-to-date lists, schedule frequent runs and compare deltas in your CRM.

#### Is this legal? Does it comply with GDPR / CCPA?

Use is your responsibility. The actor collects **publicly available data**, and you should comply with GDPR, CCPA, and applicable platform Terms of Service when storing and using the results.

#### Can I export to Google Sheets or Excel?

Yes. Export your Apify dataset as JSON, CSV, or Excel from the Apify dashboard, then import into Google Sheets or other tools.

#### Can I schedule this to run automatically?

Yes. You can schedule actor runs on Apify (via Apify’s scheduling options and/or API-based workflows) so your **google maps email list builder** stays updated.

#### Can I access results via the API?

Yes. Apify actors are designed to be triggered and queried via the Apify API, so you can pull results programmatically for your automation and data pipelines.

#### What happens when the actor encounters an error?

Even when a particular business fails, the dataset includes a `scrape_status` value (for example, `failed` or `error`) so you can see what happened and decide whether to retry or exclude those rows. The actor also pushes results as it processes them, which helps reduce lost progress during long runs.

***

### Get Help & Use Responsibly

Got a question about Google Maps Email Scraper Unlimited or a feature you'd like added? Reach out at <dataforleads@gmail.com>. We welcome feedback like “add another filtering mode for outreach readiness” or “include additional dataset fields for better deduping”—and we’re actively maintaining the actor based on user needs.

This actor collects **publicly available data**. It does not access private accounts, login-gated pages, or password-protected content. Please ensure your use complies with GDPR, CCPA, and applicable platform Terms of Service. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# 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("scrapeflux/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("scrapeflux/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 scrapeflux/google-maps-email-scraper-unlimited --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapeflux/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": "📧 Extract emails from Google Maps listings with Google Maps Email Scraper Unlimited. Save time on lead research, boost outreach, and streamline B2B prospecting with accurate, targeted contacts. 🚀 Perfect for sales & marketing teams!",
        "version": "1.0",
        "x-build-id": "6a37xhDgbiIAz0Y40"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeflux~google-maps-email-scraper-unlimited/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeflux-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/scrapeflux~google-maps-email-scraper-unlimited/runs": {
            "post": {
                "operationId": "runs-sync-scrapeflux-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/scrapeflux~google-maps-email-scraper-unlimited/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeflux-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
