# Wedding Venue & Vendor Email Extractor — Eventective (`scrapersdelight/eventective-email-extractor`) Actor

\~$7 per 1,000 emailed wedding leads ($0.004/lead + $0.003/email crawl). Scrapes Eventective venues & event vendors by city, then crawls each vendor's own website for emails, phone & socials — with MX verification, a GDPR generic-inbox filter, and a new-listing monitor. No login or API key.

- **URL**: https://apify.com/scrapersdelight/eventective-email-extractor.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 💍 Wedding Venue & Vendor Email Extractor — Eventective

**Type a city, pick a category (wedding venues, caterers, DJs, planners, …), and get back one lead row per business with an EMAIL-first contact card: `emails[]` crawled from the vendor's own website, `email_type`, MX `email_verified`, `best_contact`, plus the public phone, website, and socials from the Eventective profile. Enrichment is always on — that's the product.**

| | **This actor** | A standard Google Maps + email scraper |
|---|---|---|
| **Cost to get 1,000 _relevant_ leads** | **≈ $7** — and every one is already an event vendor | $7.50+ — **plus** you pay to scrape & enrich all the unrelated businesses you sift through to find them |
| **Source** | Eventective — a wedding/event directory, so every result is already a venue or event vendor | Google Maps — generic places, you filter the noise yourself |
| **Emails** | ✅ always-on website crawl: mailto, Cloudflare-obfuscated, (at)/(dot) deobfuscation; `emails[]` + best pick | ✅ website crawl |
| **Email quality signals** | ✅ `email_type` (role vs personal), MX `email_verified`, `email_confidence` + reason, `best_contact` | ❌ raw emails only |
| **GDPR filter** | ✅ `genericInboxOnly` — drop personal-name emails, keep info@/events@ | ❌ |
| **Wedding/event fields** | ✅ category, profile description, Eventective profile URL | ❌ no event-industry context |
| **New-listing monitor** | ✅ diff per city+category, Slack/email/webhook alerts, `new-lot-detected` pricing | ❌ |
| **Failure handling** | retries with fresh proxy session per attempt; vendor-site failures are soft misses (never crash the run); per-site crawl deadline | — |
| **Anti-bot risk** | none — Eventective is server-rendered, no login, no challenges | Google Maps scraping arms race |

A generic Maps + email scraper is the proven pattern — but it makes you scrape and enrich a pile of unrelated businesses to find the venues and vendors. This one is the same always-on-enrichment play **purpose-built for the wedding & events niche**: the directory is pre-filtered to venues and event vendors, so every lead you pay to enrich is one you'd actually sell to — no nail salons in your wedding-venue list.

---

### What does the Wedding Venue & Vendor Email Extractor do?

1. **Scrapes Eventective listings** for your city + categories (~30-60 businesses per listing page) — name, public phone, website, socials, description.
2. **Crawls every business's own website** (homepage, /contact, /about, …) for **emails** — including Cloudflare-obfuscated and `(at)/(dot)`-written ones — plus extra phones and socials the profile didn't list.
3. **Grades each email**: role vs personal (`email_type`), domain accepts mail (`email_verified`, MX via DNS-over-HTTPS), and how likely it belongs to that business (`email_confidence` high/medium/low + reason).
4. Outputs **one flat lead row** per business — paste into your CRM, Clay, Instantly, Smartlead, n8n, or Make.
5. Optional **monitor mode**: run on a schedule and get ONLY newly listed venues/vendors — already email-enriched — with Slack/email/webhook alerts.

### What data do you get per lead?

- 📛 `name` · `category` · `description` · `profile_url` · `eventective_id`
- 📧 **`email`** (best pick) · `emails[]` (all found) · `email_type` (role/personal/other) · `email_verified` (MX) · `email_confidence` + reason
- ☎️ **`phone`** (Eventective public phone, else first phone found on the website) · `phones_web[]`
- 🌐 **`website`** · `socials` (Facebook, Instagram, LinkedIn, X, YouTube, TikTok, Pinterest)
- 🎯 **`best_contact`** — the single best way to reach them (email → phone → website → social)
- 📍 `city` · `state` · `pages_crawled` · `record_id` · `is_new` (monitor mode) · `scraped_at`

### How to use it

1. Click **Try for free**.
2. Enter a **city** (e.g. `Dallas, TX`) and pick **categories**.
3. Click **Start** — every lead is enriched automatically. Open the **Dataset** tab and export CSV/JSON/Excel.
4. **For a live feed:** turn on **Monitor mode** + an Apify **Schedule** and get alerted when new venues/vendors list.

#### Quick start
```json
{ "city": "Dallas, TX", "categories": ["wedding-venues", "caterers"], "maxItems": 100 }
````

#### GDPR-safe outreach list (generic inboxes only, emails required)

```json
{ "city": "Chicago, IL", "categories": ["wedding-venues"], "genericInboxOnly": true, "requireEmail": true }
```

#### Daily new-listing monitor

```json
{ "city": "Austin, TX", "categories": ["wedding-venues", "caterers"], "monitorMode": true, "slackWebhookUrl": "https://hooks.slack.com/services/…" }
```

**Categories:** wedding-venues · venues · caterers · djs · planners · photographers · videographers · florists · bands · party-rentals · limousines · bakeries · entertainment · photo-booths · officiants — or any raw Eventective category slug.

### Who is it for?

- 💐 **Wedding & event suppliers** selling to venues, caterers, planners (the buyer who'd otherwise scrape all of Google Maps and filter)
- 🏰 **Venue-management / event-tech SaaS** building city-by-city outbound lists
- 📣 **Agencies & lead-gen shops** serving the $70B+ wedding industry
- 🤝 **Vendors prospecting partners** — DJs who want every new venue, florists who want every planner

### Pricing (pay-per-event)

| Event | What it covers | Price |
|-------|----------------|-------|
| `lot-scraped` | each venue/vendor lead returned | **$0.004** |
| `lot-detail-enriched` | each vendor website crawled for contacts | **$0.003** |
| `monitor-run-completed` | each scheduled watch run | $0.05 |
| `new-lot-detected` | each newly listed venue/vendor | $0.02 |
| `alert-delivered` | each Slack/email/webhook alert | $0.005 |

**≈ $7 per 1,000 fully emailed leads** ($0.004 + $0.003 each) — and you only pay the enrichment fee for businesses that actually have a website to crawl.

### Legal & GDPR

- **Public business-directory data.** Names, phones, websites, and socials are published openly on Eventective; emails are taken from each business's **own public website**.
- **Personal data:** some vendor sites publish personal-name emails (jane@…). Turn on **`genericInboxOnly`** to drop those and keep only generic role inboxes (info@, events@, sales@) — the GDPR-cautious default for EU outreach.
- **You are responsible for compliant outreach** — CAN-SPAM (US), GDPR/PECR (EU/UK), CASL (Canada): lawful basis, identification, opt-out.
- Scraping publicly accessible pages is generally lawful, but directory terms of use are a gray area — review your own risk tolerance and local rules before commercial use.

### FAQ

**1. How is this different from a Google Maps email extractor?**
Same enrichment idea, but the source is pre-filtered to the wedding/event industry. On Google Maps you pay to scrape and enrich every "venue-ish" business and then clean the list; here every row is already a venue, caterer, DJ, planner, etc.

**2. What's the email hit rate?**
Roughly **50-70%** of businesses with a website in live testing. Misses are mostly big-chain sites (Hilton, corporate club groups) that render their pages in JavaScript and publish no email in the HTML. Phone + website come back for nearly all leads, so every row is still actionable — `best_contact` always gives you something.

**3. Does it verify the emails?**
It MX-verifies the primary email's **domain** via DNS-over-HTTPS (`email_verified: true` = the domain accepts mail). That catches dead domains and typos; it is not a full SMTP mailbox check.

**4. What does `email_confidence` mean?**
`high` = email on the business's own domain AND MX-verified. `medium` = own/related-brand domain but unconfirmed MX, or a brand mailbox on Gmail. `low` = off-domain, eyeball before outreach. `none` = no email found.

**5. Can I get only generic inboxes (no personal data)?**
Yes — set `genericInboxOnly: true`. Personal-name emails are dropped before output; only role inboxes like info@, events@, bookings@ are kept.

**6. How do I get more emails per lead?**
Raise `maxPagesPerSite` to 5-6. The crawler visits the homepage plus contact/about/weddings pages and follows contact-ish links; more pages = a higher hit rate, slower runs.

**7. Does monitor mode re-charge me for old leads?**
No. Monitor mode remembers what it has seen (per city+category, in a persistent named store) and outputs/charges only **new** listings — each one already email-enriched.

**8. Which cities and categories work?**
Any city Eventective covers (US + Canada, thousands of metros) — pass `"Dallas, TX"` or the slug `dallas-tx`. Categories: any of the 15 friendly names above or a raw Eventective slug.

**9. Do I need proxies, an account, or an API key?**
No login, no API key. Eventective is server-rendered with no anti-bot; default Apify datacenter proxy is plenty.

**10. Can it feed Clay / Instantly / Smartlead / n8n / Make?**
Yes — pull the dataset via the Apify API or integrations. Each row is flat (email, phone, website at top level) so it maps straight into enrichment/sequencer columns.

**11. What happens when a vendor's website is down?**
A failed or slow site is a soft miss: the lead still comes out with phone/website/socials, `email_confidence: "none"`. Per-site crawl deadlines mean one dead host never stalls the run.

**12. How fast is it?**
Listings and profiles are sub-second; the website crawl adds ~1-4s per business, run 8 at a time. ~100 fully enriched leads typically complete in a few minutes.

# Actor input Schema

## `city` (type: `string`):

The city + state to pull wedding venues / event vendors for. Accepts 'Dallas, TX' or the Eventective slug 'dallas-tx'.

## `categories` (type: `array`):

What to scrape. Friendly names: wedding-venues, venues, caterers, djs, planners, photographers, videographers, florists, bands, party-rentals, limousines, bakeries, entertainment, photo-booths, officiants. (Or any raw Eventective category slug.)

## `maxItems` (type: `integer`):

Cap on total leads per run (0 = no cap). Every lead with a website gets its email crawl — give big pulls more timeout.

## `maxPagesPerSite` (type: `integer`):

How many pages of each vendor's own website to crawl for an email (homepage, /contact, /about, …). Raise to 5-6 for a higher hit rate; 2 keeps runs fast.

## `maxPagesPerCategory` (type: `integer`):

How many Eventective listing pages (~30-60 leads each) to walk per category.

## `genericInboxOnly` (type: `boolean`):

Drop personal-name emails (jane.doe@…) and keep only generic/role inboxes (info@, events@, sales@ …). Use this to avoid collecting personal data.

## `requireEmail` (type: `boolean`):

Output only leads where the website crawl found an email.

## `concurrency` (type: `integer`):

How many leads to scrape + enrich in parallel.

## `monitorMode` (type: `boolean`):

Recurring watcher: diff against the prior run (per city+category scope) and output/alert ONLY new listings — already enriched with emails. Pair with an Apify Schedule.

## `alertOnNewLead` (type: `boolean`):

In monitor mode, send an alert for each newly listed venue/vendor.

## `webhookUrl` (type: `string`):

POST endpoint for new-lead alerts.

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL.

## `emailRecipients` (type: `array`):

Emails for the new-lead digest (via apify/send-mail).

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

Proxy settings. Datacenter rotation is plenty (Eventective is server-rendered, no anti-bot).

## `diagnose` (type: `boolean`):

Dev only. Logs the first fully enriched lead, then exits.

## Actor input object example

```json
{
  "city": "Dallas, TX",
  "categories": [
    "wedding-venues"
  ],
  "maxItems": 25,
  "maxPagesPerSite": 2,
  "maxPagesPerCategory": 10,
  "genericInboxOnly": false,
  "requireEmail": false,
  "concurrency": 8,
  "monitorMode": false,
  "alertOnNewLead": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "diagnose": false
}
```

# Actor output Schema

## `leads` (type: `string`):

The dataset of wedding venues & event vendors (one item per lead, email-enriched).

# 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 = {
    "city": "Dallas, TX",
    "categories": [
        "wedding-venues"
    ],
    "maxItems": 25,
    "maxPagesPerSite": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/eventective-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 = {
    "city": "Dallas, TX",
    "categories": ["wedding-venues"],
    "maxItems": 25,
    "maxPagesPerSite": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/eventective-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 '{
  "city": "Dallas, TX",
  "categories": [
    "wedding-venues"
  ],
  "maxItems": 25,
  "maxPagesPerSite": 2
}' |
apify call scrapersdelight/eventective-email-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wedding Venue & Vendor Email Extractor — Eventective",
        "description": "~$7 per 1,000 emailed wedding leads ($0.004/lead + $0.003/email crawl). Scrapes Eventective venues & event vendors by city, then crawls each vendor's own website for emails, phone & socials — with MX verification, a GDPR generic-inbox filter, and a new-listing monitor. No login or API key.",
        "version": "0.1",
        "x-build-id": "dBLsTEf4C3fd3eS5g"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapersdelight~eventective-email-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapersdelight-eventective-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/scrapersdelight~eventective-email-extractor/runs": {
            "post": {
                "operationId": "runs-sync-scrapersdelight-eventective-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/scrapersdelight~eventective-email-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-scrapersdelight-eventective-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": {
                    "city": {
                        "title": "City (e.g. 'Dallas, TX')",
                        "type": "string",
                        "description": "The city + state to pull wedding venues / event vendors for. Accepts 'Dallas, TX' or the Eventective slug 'dallas-tx'."
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "What to scrape. Friendly names: wedding-venues, venues, caterers, djs, planners, photographers, videographers, florists, bands, party-rentals, limousines, bakeries, entertainment, photo-booths, officiants. (Or any raw Eventective category slug.)",
                        "default": [
                            "wedding-venues"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max leads",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on total leads per run (0 = no cap). Every lead with a website gets its email crawl — give big pulls more timeout.",
                        "default": 100
                    },
                    "maxPagesPerSite": {
                        "title": "Pages crawled per vendor website",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many pages of each vendor's own website to crawl for an email (homepage, /contact, /about, …). Raise to 5-6 for a higher hit rate; 2 keeps runs fast.",
                        "default": 2
                    },
                    "maxPagesPerCategory": {
                        "title": "Max listing pages per category",
                        "minimum": 1,
                        "type": "integer",
                        "description": "How many Eventective listing pages (~30-60 leads each) to walk per category.",
                        "default": 10
                    },
                    "genericInboxOnly": {
                        "title": "Generic inboxes only (GDPR-friendly)",
                        "type": "boolean",
                        "description": "Drop personal-name emails (jane.doe@…) and keep only generic/role inboxes (info@, events@, sales@ …). Use this to avoid collecting personal data.",
                        "default": false
                    },
                    "requireEmail": {
                        "title": "Only keep leads with an email",
                        "type": "boolean",
                        "description": "Output only leads where the website crawl found an email.",
                        "default": false
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many leads to scrape + enrich in parallel.",
                        "default": 8
                    },
                    "monitorMode": {
                        "title": "Monitor mode (new-listing watcher)",
                        "type": "boolean",
                        "description": "Recurring watcher: diff against the prior run (per city+category scope) and output/alert ONLY new listings — already enriched with emails. Pair with an Apify Schedule.",
                        "default": false
                    },
                    "alertOnNewLead": {
                        "title": "Alert on new leads",
                        "type": "boolean",
                        "description": "In monitor mode, send an alert for each newly listed venue/vendor.",
                        "default": true
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "POST endpoint for new-lead alerts."
                    },
                    "slackWebhookUrl": {
                        "title": "Slack webhook URL",
                        "type": "string",
                        "description": "Slack incoming-webhook URL."
                    },
                    "emailRecipients": {
                        "title": "Email recipients",
                        "type": "array",
                        "description": "Emails for the new-lead digest (via apify/send-mail).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. Datacenter rotation is plenty (Eventective is server-rendered, no anti-bot).",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "diagnose": {
                        "title": "Diagnostic mode (dev)",
                        "type": "boolean",
                        "description": "Dev only. Logs the first fully enriched lead, then exits.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```