# Google Maps Email Extractor (`khadinakbar/google-maps-email-extractor`) Actor

Extract business emails from Google Maps at scale. Search by keyword + city, get verified emails plus name, phone, website, address, rating, and social links. Email-first — filter to places with email in one click. Pay only when an email is actually found. No login, no setup, no subscription.

- **URL**: https://apify.com/khadinakbar/google-maps-email-extractor.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, MCP servers, AI
- **Stats:** 3 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 place founds

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 Extractor — Find Business Emails by Keyword + City

**Extract verified business emails from [Google Maps](https://www.google.com/maps) at scale.** Enter a keyword (like `dentists`, `real estate agents`, `plumbers`) and a city — get a CRM-ready list of businesses with **email, phone, website, address, category, rating, and social links**. Email-first: pay only when a verified email is found, and one-click filter to drop places without emails.

### What does Google Maps Email Extractor do?

Google Maps Email Extractor searches Google Maps for any business type in any city, opens each place, and then visits the business website to extract the **publicly listed email address**. You get a flat, CRM-ready record per business — ideal for cold email campaigns, agency prospecting, local lead lists, and market research.

This actor runs on the **Apify platform** — so you get **API access, scheduled runs, Zapier/Make integrations, residential proxy rotation, run monitoring, and export to CSV / JSON / Excel** out of the box. No login, no subscription, no Google Maps API key needed.

### 🚀 Quick output example

```json
{
  "business_name": "ONE Dental Miami",
  "email": "info@onedentalmiami.com",
  "phone": "+1 305-555-0123",
  "website": "https://onedentalmiami.com",
  "full_address": "789 Brickell Ave, Miami, FL 33131, USA",
  "category": "Dental clinic",
  "rating": 4.9,
  "review_count": 218,
  "facebook": "https://facebook.com/onedentalmiami",
  "instagram": "https://instagram.com/onedentalmiami",
  "linkedin": null,
  "twitter": null,
  "latitude": 25.7617,
  "longitude": -80.1918,
  "google_maps_url": "https://www.google.com/maps/place/...",
  "place_id": "0x88d9b...:0x3f7...",
  "is_permanently_closed": false,
  "scraped_at": "2026-04-24T12:33:20.286Z",
  "source_query": "dentists in Miami, FL"
}
````

### 💵 Pricing

Pay-per-event. No subscription.

| Event | Price |
|---|---|
| Actor start | $0.00005 (charged once per run per GB RAM) |
| Place found | **$0.003** per business extracted |
| Email found | **$0.005** per verified email (charged **only** when email is actually found — no charge for empty enrichment) |

**Typical cost**: scraping 100 dentists in Miami with ~60% email hit rate = 100 × $0.003 + 60 × $0.005 = **$0.60/run**. Want only records with email? Turn on "Only return businesses with an email" — you still pay per place scanned, but the output contains only valid leads.

### Why use Google Maps Email Extractor?

- **Sales prospecting**: build targeted B2B cold-email lists by niche + city.
- **Agency lead generation**: compile local business lists for client campaigns.
- **Market research**: see who the active players are in any local category.
- **CRM enrichment**: append emails and socials to existing business databases.
- **Local SEO / competitive analysis**: collect ratings, review counts, and websites in a geographic area.

### How to use Google Maps Email Extractor

1. Open the actor and click **Start** to try the default (`dentists in Miami, FL`).
2. Change the **Search keyword** to your niche — e.g. `real estate agents`, `plumbers`, `yoga studios`.
3. Change **City / region** to your target market — `Austin, TX`, `London, UK`, `Berlin, Germany`.
4. Set **Max businesses to extract** (20 is a good first run; scale up from there).
5. (Optional) Toggle **Only return businesses with an email** to filter output to leads with verified emails.
6. (Optional) Set **Minimum Google rating** to focus on higher-quality businesses.
7. Click **Start** — results stream to the Dataset tab as they're extracted.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQuery` | string | `dentists` | Business keyword or niche |
| `location` | string | `Miami, FL` | City, region, or country |
| `maxResults` | integer | `20` | Max businesses to extract (1 to 2,000) |
| `skipWithoutEmail` | boolean | `false` | Return only businesses with an email |
| `minRating` | number | `0` | Minimum Google rating (0 = all) |
| `skipClosedPlaces` | boolean | `true` | Skip permanently closed businesses |
| `language` | string | `en` | Google Maps UI language |
| `startUrls` | array | `[]` | Alternative: paste Google Maps search or place URLs directly |

### Output data fields

| Field | Type | Description |
|---|---|---|
| `business_name` | string | Business name from Google Maps |
| `email` | string | null | Verified email from the business website |
| `phone` | string | null | Phone number from Google Maps |
| `website` | string | null | Business website |
| `full_address` | string | Complete address with city, state, postal code |
| `category` | string | Primary category (e.g., Dentist, Restaurant) |
| `rating` | number | null | Google rating 1.0–5.0 |
| `review_count` | integer | Total review count |
| `latitude` / `longitude` | number | GPS coordinates |
| `google_maps_url` | string | Direct Google Maps link |
| `place_id` | string | Google Place ID |
| `facebook` / `instagram` / `linkedin` / `twitter` | string | null | Social profiles from the business website |
| `is_permanently_closed` | boolean | Closure signal from Google Maps |
| `scraped_at` | string (ISO 8601) | Extraction timestamp |
| `source_query` | string | Original keyword + city or URL |

You can download the dataset in **JSON, HTML, CSV, or Excel** from the Output tab.

### Tips and advanced options

- **Use specific niches**: `personal injury lawyers` beats `lawyers` — tighter niche = higher relevance per result and higher email hit rate.
- **One city per run**: for reliability, run one `searchQuery` + one `location` per actor run. For multi-city campaigns, schedule parallel runs via the Apify API or the Schedules tab.
- **Filter with `skipWithoutEmail: true`** when you want a clean cold-email list and don't care about businesses without a public email.
- **Rating filter to prune low-quality leads**: set `minRating: 4.0` when you want only highly-rated active businesses.
- **Scale with the API**: trigger runs programmatically from your CRM or n8n/Zapier/Make workflows — each run produces a fresh dataset you can pipe into your cold-email tool.

### How it works (under the hood)

1. Loads Google Maps search results for your keyword + city using a real Chrome browser.
2. Scrolls the results panel to load as many businesses as needed.
3. Opens each business place card and extracts structured data (name, phone, rating, website, coordinates).
4. Visits the business website (home page, `/contact`, `/about`) via a fast HTTP client and runs an email-validation regex filtered against common false-positive patterns.
5. Pushes each business to the dataset with a deduplication guarantee.

Reliability engineering:

- **Residential proxies** via Apify's proxy network (Google Maps blocks datacenter IPs).
- **Session pool** with cookie persistence — same IP and fingerprint across a business session.
- **Session retirement** on 403/429 responses.
- **Circuit breaker**: if more than 50% of recent requests fail, the run aborts cleanly rather than burning your budget.
- **Email enrichment budget**: each website gets at most 15 seconds across 3 pages (home → `/contact` → `/about`). No runaway enrichment.

### Related actors in this portfolio

- [📧 Google Maps Leads Scraper](https://apify.com/khadinakbar/google-maps-leads-scraper) — same data with reviews and a lead-quality score.
- [🔎 B2B Lead Finder + Enrichment](https://apify.com/khadinakbar/b2b-lead-finder-enrichment) — multi-source B2B enrichment.
- [📬 Bulk Website Contact Extractor](https://apify.com/khadinakbar/bulk-website-contact-extractor) — feed a list of domains, get emails back.
- [👤 LinkedIn Profile Email Scraper](https://apify.com/khadinakbar/linkedin-profile-email-scraper) — LinkedIn profiles + emails.
- [🎯 Universal Lead Finder](https://apify.com/khadinakbar/universal-lead-finder) — any niche + city in, leads out.

### FAQ

**Is scraping Google Maps legal?**
Google Maps displays publicly available business information. This actor accesses only the public-facing listings, same as any visitor would. Users are responsible for complying with Google's Terms of Service, local regulations (GDPR, CAN-SPAM, CCPA, etc.), and outreach consent rules where applicable. This actor is provided for legitimate sales prospecting, research, and lead-generation use cases — it is not intended for spamming, harassment, or any unlawful purpose.

**Why didn't all businesses have an email?**
Not every business publishes an email on their website. Industry average is 40–70% email hit rate depending on niche. Professional services (lawyers, dentists, real estate) typically have higher rates. Restaurants and retail tend lower. Use `skipWithoutEmail: true` to auto-drop records without email.

**Can I use the extracted emails for cold outreach?**
Follow applicable law in your jurisdiction (CAN-SPAM in the US, GDPR in the EU, CASL in Canada, etc.). Most regimes require: accurate sender identity, a real subject line, a physical address, and a working unsubscribe mechanism. Use this actor for B2B outreach only; do not use it for consumer spam.

**How many businesses can I scrape?**
Google Maps typically shows up to ~120 results per search query. For more coverage, split by neighborhood, postal code, or sub-niche.

**Run failed or slow?**
Open the Issues tab on the actor page with your run ID and I'll take a look. If you need bulk runs, scheduled runs, or a custom pipeline feeding into your stack, I build custom solutions on Apify — reach out via the store page.

### Legal disclaimer

This actor scrapes only publicly accessible data from Google Maps and linked business websites. Users are solely responsible for how they use the extracted data. Do not use the output to harass individuals, violate terms of service, or break applicable privacy and spam laws. No affiliation with Google Inc.

### Support

Found a bug or want a new feature? Open an issue on the actor page. For custom scraping pipelines, contact me through Apify.

# Actor input Schema

## `searchQuery` (type: `string`):

Business type or niche to search Google Maps for (e.g., 'dentists', 'real estate agents', 'plumbers'). Combined with the location below into a Google Maps query. Defaults to 'dentists'. NOT a Google Maps URL — paste a URL into the 'Google Maps URLs' field instead.

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

City, region, or country to search in (e.g., 'Miami, FL' or 'London, UK'). Simple 'City, Country' or 'City, State' formats work best. Defaults to 'Miami, FL'. Leave empty only if pasting a full Google Maps URL that already contains the area.

## `maxResults` (type: `integer`):

Maximum number of businesses to extract per search. Lower = faster and cheaper. Set 5-10 for testing, 50-200 for typical campaigns, 500+ for bulk lists. Hard cap at 2,000 per run — split larger jobs across cities for reliability.

## `skipWithoutEmail` (type: `boolean`):

When enabled, businesses without a verified email are dropped from the output — you pay only for records with emails. Useful when building targeted cold-outreach lists. When off, all businesses are returned (with or without email).

## `minRating` (type: `number`):

Only include businesses with a Google rating >= this value (1.0 to 5.0). Set to 0 to include all businesses regardless of rating. Businesses with no rating are included when this is 0 and excluded otherwise.

## `skipClosedPlaces` (type: `boolean`):

Skip businesses marked as 'Permanently closed' on Google Maps. Recommended for cold outreach lists to avoid wasting effort on defunct businesses.

## `language` (type: `string`):

Language code for the Google Maps interface — affects business names, categories, and addresses. Use 'en' for English, 'es' for Spanish, 'fr' for French, etc. Only affects Google Maps UI, not the email extraction step.

## `startUrls` (type: `array`):

Paste Google Maps search URLs or place URLs here if you want to use them instead of a keyword + location. Each URL replaces one keyword search. Leave empty if using 'Search keyword' + 'City' above.

## Actor input object example

```json
{
  "searchQuery": "real estate agents",
  "location": "Austin, TX",
  "maxResults": 20,
  "skipWithoutEmail": false,
  "minRating": 0,
  "skipClosedPlaces": true,
  "language": "en",
  "startUrls": []
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset of businesses scraped from Google Maps with verified emails extracted from their websites.

# 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 = {
    "searchQuery": "dentists",
    "location": "Miami, FL",
    "maxResults": 20,
    "language": "en",
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/google-maps-email-extractor").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 = {
    "searchQuery": "dentists",
    "location": "Miami, FL",
    "maxResults": 20,
    "language": "en",
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/google-maps-email-extractor").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 '{
  "searchQuery": "dentists",
  "location": "Miami, FL",
  "maxResults": 20,
  "language": "en",
  "startUrls": []
}' |
apify call khadinakbar/google-maps-email-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Email Extractor",
        "description": "Extract business emails from Google Maps at scale. Search by keyword + city, get verified emails plus name, phone, website, address, rating, and social links. Email-first — filter to places with email in one click. Pay only when an email is actually found. No login, no setup, no subscription.",
        "version": "1.1",
        "x-build-id": "9RziiKxKhcvDRpvT3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~google-maps-email-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-google-maps-email-extractor",
                "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/khadinakbar~google-maps-email-extractor/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-google-maps-email-extractor",
                "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/khadinakbar~google-maps-email-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-google-maps-email-extractor",
                "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",
                "properties": {
                    "searchQuery": {
                        "title": "🔍 Search keyword",
                        "type": "string",
                        "description": "Business type or niche to search Google Maps for (e.g., 'dentists', 'real estate agents', 'plumbers'). Combined with the location below into a Google Maps query. Defaults to 'dentists'. NOT a Google Maps URL — paste a URL into the 'Google Maps URLs' field instead."
                    },
                    "location": {
                        "title": "📍 City / region",
                        "type": "string",
                        "description": "City, region, or country to search in (e.g., 'Miami, FL' or 'London, UK'). Simple 'City, Country' or 'City, State' formats work best. Defaults to 'Miami, FL'. Leave empty only if pasting a full Google Maps URL that already contains the area."
                    },
                    "maxResults": {
                        "title": "💯 Max businesses to extract",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of businesses to extract per search. Lower = faster and cheaper. Set 5-10 for testing, 50-200 for typical campaigns, 500+ for bulk lists. Hard cap at 2,000 per run — split larger jobs across cities for reliability.",
                        "default": 20
                    },
                    "skipWithoutEmail": {
                        "title": "📧 Only return businesses with an email",
                        "type": "boolean",
                        "description": "When enabled, businesses without a verified email are dropped from the output — you pay only for records with emails. Useful when building targeted cold-outreach lists. When off, all businesses are returned (with or without email).",
                        "default": false
                    },
                    "minRating": {
                        "title": "⭐ Minimum Google rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only include businesses with a Google rating >= this value (1.0 to 5.0). Set to 0 to include all businesses regardless of rating. Businesses with no rating are included when this is 0 and excluded otherwise.",
                        "default": 0
                    },
                    "skipClosedPlaces": {
                        "title": "⏩ Skip permanently closed businesses",
                        "type": "boolean",
                        "description": "Skip businesses marked as 'Permanently closed' on Google Maps. Recommended for cold outreach lists to avoid wasting effort on defunct businesses.",
                        "default": true
                    },
                    "language": {
                        "title": "🌍 Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "nl",
                            "pl",
                            "ru",
                            "ja",
                            "ko",
                            "zh-CN",
                            "ar",
                            "tr",
                            "hi"
                        ],
                        "type": "string",
                        "description": "Language code for the Google Maps interface — affects business names, categories, and addresses. Use 'en' for English, 'es' for Spanish, 'fr' for French, etc. Only affects Google Maps UI, not the email extraction step.",
                        "default": "en"
                    },
                    "startUrls": {
                        "title": "🔗 Google Maps URLs (optional — alternative to keyword search)",
                        "type": "array",
                        "description": "Paste Google Maps search URLs or place URLs here if you want to use them instead of a keyword + location. Each URL replaces one keyword search. Leave empty if using 'Search keyword' + 'City' above.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
