# Restaurant Email Scraper (`solid-scraper/restaurant-email-scraper`) Actor

🍽️ Restaurant Email Scraper finds verified email contacts for restaurants by location, cuisine & keywords. Ideal for outreach, marketing & lead generation—fast, accurate, and GDPR-friendly. 🚀📧 Boost campaigns instantly!

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

## Pricing

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

### Restaurant Email Scraper 📬

**Restaurant Email Scraper** is an Apify actor that helps you find restaurants in specific locations and extract their contact information—especially email addresses—so you can build a targeted restaurant contact email list faster. It’s designed for use cases like restaurant emails finder workflows, restaurant prospecting email scraper projects, and restaurant CRM email scraping for B2B outreach.

Whether you’re a marketer, sales team, data analyst, or researcher, this tool streamlines scrape restaurant emails efforts by converting public web contact pages into a structured dataset—saving you hours of manual work.

---

### 🤝 Why choose Restaurant Email Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ **All-in-one restaurant email scraping** | Finds businesses by location and extracts emails, phone numbers, and social media profiles. |
| ✅ **Built-in resilience for scraping** | Includes retries/fallbacks for resilience to improve results when websites are inconsistent. |
| ✅ **Structured, dataset-ready output** | Saves results in a consistent table format so you can export and analyze quickly. |
| ✅ **Scale with limits** | Lets you cap results with `maxBusinesses` and optional per-location limits via `scrapeMaxBusinessesPerLocation`. |
| ✅ **Proxy support for reliability** | Supports proxyConfiguration to help reduce IP blocking and rate-limit issues. |
| ✅ **Automation-friendly for outreach** | Outputs contact fields that are easy to plug into CRM lead lists and targeted email campaigns. |

---

### ✨ Key features

- 📍 **Restaurant discovery by niche + location:** Uses your `googleMapsSearchTerm` and `googleMapsLocation` inputs to target restaurants in the areas you care about.
- ✉️ **Restaurant emails finder output:** Extracts email addresses into dataset rows for downstream lead generation and targeted restaurant outreach emails.
- 📞 **Phone number extraction:** Collects phone numbers alongside emails for richer restaurant contact information.
- 🔗 **Social media profile extraction:** Captures social links so you can enrich each restaurant before outreach.
- 🌐 **Website-based contact scraping:** Pulls contact details from each business website to improve completeness of scraped restaurant contact information.
- 💾 **Real-time dataset saving:** Pushes results to the Apify dataset as it scrapes, reducing the chance of losing progress.
- 🛡️ **Proxy configuration support:** Helps improve reliability during larger scrape restaurant emails jobs.

---

### 🧩 Input

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

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

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `googleMapsSearchTerm` | Yes | Enter the business type or niche for the restaurant email scraping (e.g., `coffee shops`, `dentists`). Use `Restaurant` for general discovery. |
| `googleMapsLocation` | Yes | Target geographic location(s) for the search (e.g., `Miami, Florida`). Provide as a list (e.g., `["New York"]`). |
| `maxBusinesses` | No | Maximum businesses with emails to find. Range is `1-1000`. The scraper stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | No | Controls how the limit is applied across multiple locations. If `true`, it aims for up to `maxBusinesses` results per location; if `false`, it combines all locations up to a single total limit. |
| `proxyConfiguration` | No | Proxy settings for scraping. Recommended for large-scale scraping. |
| `proxyConfiguration` • `proxy support` | No | Enable Apify Proxy (pre-filled as `true`). |

***

### 📦 Output

After execution, the actor saves results in a dataset view titled **Businesses with Contact Information** as a flattened structure (one row per email found when emails exist).

Sample output row:

```json
{
  "street_address": "123 Example St",
  "city": "New York",
  "zip": "10001",
  "state": "NY",
  "country_code": "US",
  "full_address": "123 Example St New York NY 10001 US",
  "website": "https://example.com",
  "avg_rating": 4.5,
  "total_reviews": 120,
  "name": "Example Restaurant",
  "place_id": "ChIJN1t_tDeuEmsRUsoyG83frY4",
  "phone": "+1 555-123-4567",
  "lat": 40.7128,
  "long": -74.006,
  "scraped_emails": [],
  "scraped_phones": [],
  "scraped_social_media": [],
  "emails_found": 0,
  "pages_scraped": 0,
  "scrape_status": "no_website",
  "email_found": ""
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | Business name of the restaurant. |
| `website` | string | Business website (used to scrape contact details). |
| `phone` | string | Phone number associated with the business listing. |
| `full_address` | string | Combined address string. |
| `city` | string | City from the business listing. |
| `state` | string | State from the business listing. |
| `zip` | string | ZIP/postal code from the business listing. |
| `country_code` | string | Country code associated with the business listing. |
| `scraped_emails` | array | List of scraped email addresses (may be empty depending on results). |
| `scraped_phones` | array | List of scraped phone numbers from the business website. |
| `scraped_social_media` | array | List of scraped social media/profile links. |
| `emails_found` | number | Count of emails found for the business. |
| `pages_scraped` | number | Number of pages processed while scraping the website. |
| `avg_rating` | number | Average rating from the business listing. |
| `total_reviews` | number | Total number of reviews from the business listing. |
| `lat` | number | Latitude for the business. |
| `long` | number | Longitude for the business. |
| `place_id` | string | Place identifier from the discovery step. |
| `scrape_status` | string | Status text such as `success`, `failed`, `no_website`, or `error`. |

**Note on email rows:** when emails are found, the actor flattens results by pushing one row per discovered email using `email_found`, while removing `scraped_emails` from that flattened row copy.

***

### ▶️ How to use Restaurant Email Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at [console.apify.com](https://console.apify.com) and go to the **Actors** tab.

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

3. **Add your inputs**\
   In the **INPUT** section, set:
   `googleMapsSearchTerm` (your restaurant niche) and `googleMapsLocation` (one or more locations).

4. **Set your limits (recommended)**\
   Adjust `maxBusinesses` to control how many businesses you want with emails.\
   If you provide multiple locations, decide whether to enable `scrapeMaxBusinessesPerLocation`.

5. **Configure proxy (optional but recommended for scale)**\
   Use `proxyConfiguration` if you’re running larger jobs. The form supports `proxy support`.

6. **Run the actor**\
   Click **Run**. Watch the logs for progress updates as the actor collects restaurant contacts and scrapes websites for email scraping.

7. **Open the dataset & export**\
   After the run completes, open the output dataset titled **Businesses with Contact Information**, preview results, and export to your preferred format (JSON/CSV depending on Apify export options).

No coding required—get targeted restaurant outreach emails in minutes. 🚀

***

### 🧠 Advanced features & SEO optimization

- 🎯 **Engineered for restaurant email scraping:** Works specifically as a restaurant email scraper for B2B lead building, capturing emails alongside phone and social profiles.
- 🌐 **Website-first contact extraction:** Improves results by scraping each business website for contact details rather than relying on listing-only data.
- 🧰 **Designed for outreach-ready datasets:** Pushes results directly into the Apify dataset so restaurant contact email list building is fast and repeatable.
- 🛡️ **Proxy support for reliable scraping:** Includes `proxyConfiguration` options to help maintain stability during larger restaurant emails finder projects.
- 💾 **Flexible limits for scale:** Use `maxBusinesses` and `scrapeMaxBusinessesPerLocation` to control output volume like a restaurant prospecting email scraper.

***

### 📌 Best use cases

- 📈 **Marketing teams building restaurant lead lists:** Export restaurant emails and contact fields to power targeted outreach campaigns.
- 🧾 **B2B sales for local services:** Build prospecting sequences by combining email, phone, and social media links for restaurants in chosen cities.
- 🔍 **Data analysts enriching local datasets:** Use structured fields like `place_id`, address parts, and rating/review counts alongside emails.
- 🗺️ **Local research & competitive intelligence:** Compare restaurants across multiple `googleMapsLocation` values with consistent scraped contact information.
- 🤝 **Recruiters and partnerships ops:** Find the right contact points for partnership inquiries by collecting restaurant owner email scraper style contact data.
- 💻 **CRM pipeline automation:** Ingest dataset output into a CRM workflow for restaurant CRM email scraping and follow-up segmentation.

***

### 🔧 Technical specifications

**Supported Input Formats**

- ✅ `googleMapsSearchTerm`: string
- ✅ `googleMapsLocation`: array of strings (e.g., `["New York"]`)
- ✅ `maxBusinesses`: integer within `1-1000`
- ✅ `scrapeMaxBusinessesPerLocation`: boolean
- ✅ `proxyConfiguration`: object with `proxy support`

**Proxy Support**

- ✅ `proxyConfiguration` supported via Apify Proxy toggle (`proxy support`)

**Retry Mechanism**

- ✅ Includes retries/fallbacks for resilience (details are handled internally)

**Dataset Structure**

- ✅ Dataset view: **Businesses with Contact Information**
- ✅ Flattened output per email when emails are found
- ✅ Includes business fields (address, coordinates, rating) plus scrape fields (emails/phones/social)

**Rate Limits & Performance**

- ✅ Controlled via concurrency and scrape limits (tuned for practical speed and stability)
- ✅ Hard stop when `maxBusinesses` target is reached

**Limitations**

- ❌ Businesses with no website may not produce email results (they are pushed with `scrape_status` like `no_website` depending on settings).
- ❌ Output quality depends on publicly available contact information on each business website.

***

### ❓ FAQ

#### What does Restaurant Email Scraper extract?

✅ It extracts business details (like `name`, `website`, `phone`, and address fields) and scrapes websites to collect `scraped_emails`, `scraped_phones`, and `scraped_social_media`, along with counts like `emails_found` and metadata like `pages_scraped` and `scrape_status`.

#### How do I control how many restaurants I get?

Use `maxBusinesses` to set the target number of businesses with emails. If you run multiple `googleMapsLocation` values, you can enable `scrapeMaxBusinessesPerLocation` to aim for up to `maxBusinesses` results per location, instead of a single combined total.

#### Can I scrape multiple locations in one run?

Yes. Provide multiple entries in `googleMapsLocation` (it expects an array). The actor will process each location and apply your limit strategy based on `scrapeMaxBusinessesPerLocation`.

#### What is stored in the dataset?

The dataset view stores the business fields (e.g., `full_address`, `city`, `state`, `zip`, `avg_rating`) plus scrape results (e.g., `scraped_emails`, `scraped_phones`, `scraped_social_media`, `emails_found`, `pages_scraped`, `scrape_status`).

#### Does it save results as it goes?

Yes. It pushes data into the Apify dataset during the website scraping step, so progress is captured instead of waiting for the entire run to finish.

#### Do I need to provide proxy settings?

No. Proxy settings are optional. However, for large-scale restaurant email scraper runs, `proxyConfiguration` is recommended to improve reliability.

#### Is it legal to use this for email list building?

✅ The actor collects information only from **publicly accessible sources**. You are responsible for complying with applicable laws (including GDPR/CCPA where relevant), spam regulations, and each website’s terms of service.

#### Can you help with issues or custom requests?

For support or feature requests related to Restaurant Email Scraper, email <dataforleads@gmail.com>.

***

### 🤝 Support & feature requests

Want to improve Restaurant Email Scraper for your restaurant email scraper workflows? We’d love to hear from you.

- 💡 **Feature Requests:** Examples include enhancements like more export formats, additional contact-field parsing, or tighter dataset shaping for restaurant contact email list building.
- 📧 **Contact:** Reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for Restaurant Email Scraper. 🙌

***

### 🏁 Closing CTA / Final thoughts

*If you need the most comprehensive Restaurant Email Scraper for restaurant emails finder workflows, run it with your target niche and locations and let the dataset output do the heavy lifting.*

Try Restaurant Email Scraper today and turn public restaurant contact information into outreach-ready results at scale. 🚀

***

### Disclaimer

**The Restaurant Email Scraper collects information only from publicly accessible sources.** It does not access private profiles, authenticated data, or password-protected pages.

You are responsible for ensuring your use of the data complies with applicable laws and regulations (including GDPR/CCPA where relevant), spam regulations, and the terms of service of the websites you scrape.

For data removal requests, contact <dataforleads@gmail.com>. Always use this tool responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

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

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

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

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

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

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

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

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

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

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

## Actor input object example

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

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "googleMapsSearchTerm": "Restaurant",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/restaurant-email-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "googleMapsSearchTerm": "Restaurant",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/restaurant-email-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "googleMapsSearchTerm": "Restaurant",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call solid-scraper/restaurant-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Restaurant Email Scraper",
        "description": "🍽️ Restaurant Email Scraper finds verified email contacts for restaurants by location, cuisine & keywords. Ideal for outreach, marketing & lead generation—fast, accurate, and GDPR-friendly. 🚀📧 Boost campaigns instantly!",
        "version": "1.0",
        "x-build-id": "g171C3EXUdbeiO6NV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~restaurant-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-restaurant-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solid-scraper~restaurant-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-restaurant-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solid-scraper~restaurant-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-restaurant-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "googleMapsLocation",
                    "googleMapsSearchTerm"
                ],
                "properties": {
                    "googleMapsSearchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').",
                        "default": "Restaurant"
                    },
                    "googleMapsLocation": {
                        "title": "Location",
                        "type": "array",
                        "description": "Target geographic location for the email scraper (e.g., 'Miami, Florida').",
                        "default": [
                            "New York"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxBusinesses": {
                        "title": "Maximum Businesses With Emails",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Target number of businesses to find (1-1000). The scraper will stop when this target is reached.",
                        "default": 5
                    },
                    "scrapeMaxBusinessesPerLocation": {
                        "title": "Scrape Max Businesses Per Location",
                        "type": "boolean",
                        "description": "If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for scraping. Recommended for large-scale scraping."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
