# B2B Lead Scraper: Emails, Phones & Decision-Makers (`logiover/b2b-lead-scraper`) Actor

Pick a sector and country — get thousands of fresh B2B leads. Finds companies, crawls their sites for verified business emails, decision-maker names & titles, phones, address & socials, detects each company's email pattern, and verifies emails by MX. Apollo alternative — no login, no cookies.

- **URL**: https://apify.com/logiover/b2b-lead-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Lead generation, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 🎯 Leads Scraper — B2B Email, Phone & Decision-Maker Lead Generation by Sector + Country

**Pick a sector. Pick a country. Get thousands of fresh, verified B2B leads.**

Stop buying stale, recycled lead lists that everyone else already owns. **Leads Scraper** builds *brand-new* prospect lists in real time — it targets companies by **industry and location**, scans their websites with modern crawling technology, and extracts **business emails, decision-maker names & job titles, phone numbers, postal addresses and social profiles** — then verifies every email by MX. No login, no cookies, no Apollo/ZoomInfo subscription, no per-credit paywall.

> The smart, affordable **Apollo.io / ZoomInfo / Lusha / Hunter.io alternative** for sales teams, agencies, recruiters and founders who want *their own* proprietary lead database — generated on demand, not rented from a shared one.

---

### ⚡ Why Leads Scraper beats a recycled database

| | Old-school lead databases | 🎯 Leads Scraper |
|---|---|---|
| **Freshness** | Months/years old, dead emails | **Real-time** — crawled the moment you run it |
| **Exclusivity** | Sold to hundreds of competitors | **Yours** — built from your exact filters |
| **Targeting** | Generic firmographics | **Sector + Country** (and city) precision |
| **Access** | Login, cookies, export credits | **None** — no account, no cookies, no credits |
| **Coverage** | One region/vertical | **Any industry, any country** worldwide |
| **Price** | $$$$/month subscriptions | Pay only for what you scrape |

---

### ✨ What you get for every company

- ✅ **Verified business emails** — found on-page **and** validated by MX/syntax, each labeled by confidence
- ✅ **Decision-maker contacts** — real names + job titles (CEO, Founder, Owner, Partner, Manager…) tied to their email
- ✅ **Company email pattern** detection (`first.last@`, `flast@`…) for outreach at scale
- ✅ **Phone numbers** (normalized & de-duplicated)
- ✅ **Postal address** (street, city, postcode)
- ✅ **Social profiles** — LinkedIn, Facebook, Instagram, X (Twitter), YouTube
- ✅ **Company name, domain & website**

All structured, all exportable to **CSV, Excel, JSON, or your CRM** via API/integrations.

---

### 🚀 How it works (the engine under the hood)

Leads Scraper runs a **multi-stage discovery-and-enrichment pipeline** powered by custom algorithms:

1. **🎯 Intelligent targeting** — you choose a *sector* and *country* (and optional cities). The Actor maps your niche to global open business datasets and the open web, fanning out across locations for maximum coverage.
2. **🌐 Modern website crawling** — it visits each company's site (home, contact, about, team & individual people pages) using a fast, lightweight HTTP engine — no bloated browser, so it's cheap and scales to thousands of sites per run.
3. **🧠 Smart extraction** — proprietary parsers pull emails, phones, socials and **named decision-makers with titles** from each page, filtering out junk, third-party and placeholder data.
4. **🔑 Email-pattern intelligence** — it detects each company's email format and (optionally) reconstructs likely decision-maker emails.
5. **✔️ Verification** — every email is checked for syntax and live MX records, then labeled `found_mx_valid`, `guessed_mx_valid`, etc. — so you know exactly what you're sending to.

The result: **the freshest, most targeted lead list on the market — built in minutes.**

---

### 📥 Input

Just two fields to start — **sector** and **country**:

```json
{
  "sector": "dentist",
  "country": "Germany",
  "maxLeads": 2000
}
````

| Field | Type | Description |
|-------|------|-------------|
| `sector` | string | Industry/niche to target — e.g. `lawyer`, `dentist`, `marketing agency`, `real estate`, `plumber`, `restaurant`, `insurance` |
| `country` | string | Target country — e.g. `United States`, `Germany`, `United Kingdom` |
| `cities` | array | *(optional)* Specific cities; otherwise major cities are used automatically |
| `maxLeads` | integer | How many companies to return (scale up for thousands) |
| `discovery` | select | `osm` (recommended, high volume) or `search` (search-engine mode) |
| `maxPagesPerSite` | integer | Pages crawled per company (home + contact/about/team) |
| `maxProfilesPerSite` | integer | Individual people-profile pages to crawl (where named emails live) |
| `requireEmail` | boolean | Keep only leads with an email (default **off** for max volume) |
| `guessEmails` | boolean | Reconstruct likely personal emails from name + pattern (labeled `guessed`) |
| `verifyEmails` | boolean | MX + syntax verification (default **on**) |
| `extraStartUrls` | array | Skip discovery and enrich your own list of company sites |

***

### 📤 Output

One clean record per company:

```json
{
  "companyName": "Wolf Law, LLC",
  "domain": "wolflawcolorado.com",
  "website": "https://wolflawcolorado.com/",
  "country": "United States",
  "sector": "lawyer",
  "address": "South Colorado Boulevard, 1385, Denver, 80222",
  "emailPattern": "first",
  "companyEmails": [
    { "email": "info@wolflawcolorado.com", "source": "page", "status": "found_mx_valid" }
  ],
  "persons": [
    { "name": "Jeffrey Wolf", "title": "Attorney", "email": "jeffrey@wolflawcolorado.com", "emailSource": "page", "status": "found_mx_valid" }
  ],
  "phones": ["+17207898926"],
  "socials": { "linkedin": "https://linkedin.com/company/wolf-law" },
  "scrapedAt": "2026-05-21T10:00:00.000Z"
}
```

#### Email status labels

| Status | Meaning |
|--------|---------|
| `found_mx_valid` | Email found on the website; domain accepts mail ✅ |
| `guessed_mx_valid` | Built from the company's email pattern; domain accepts mail |
| `found` / `guessed` | Verification turned off |
| `no_mx` | Domain has no mail server (filtered out by default) |

> ℹ️ ~15–28% of B2B domains are "catch-all", where individual mailboxes can't be confirmed — these stay at `*_mx_valid`. Pattern-built emails are always clearly labeled `guessed`, so you stay in control of deliverability.

***

### 💼 Use cases

- **Cold email & outbound sales** — fresh, targeted prospect lists for your SDRs
- **Local lead generation** — find every dentist, lawyer, plumber, agency in a city/country
- **Agency lead gen** — build client prospect lists on demand
- **Recruiting** — source companies and decision-makers in any niche
- **Market research & TAM mapping** — map an entire industry in a region
- **CRM enrichment** — feed verified emails, phones & addresses into HubSpot, Salesforce, Pipedrive
- **Direct mail & telemarketing** — high address & phone coverage even where email is scarce

***

### 🌍 Works for any industry, any country

Lawyers, dentists, doctors, accountants, insurance agencies, real estate, marketing & advertising agencies, software companies, consultants, architects, restaurants, hotels, plumbers, electricians, salons, gyms, pharmacies, car dealers, financial advisors — and hundreds more — across the **United States, United Kingdom, Germany, France, Spain, Italy, Netherlands, Canada, Australia, and worldwide.**

***

### ❓ FAQ

**Is this a free Apollo.io alternative?**
Yes — it generates B2B leads (emails, phones, decision-makers) without an Apollo, ZoomInfo or Lusha account, no cookies, and no export credits. You only pay for your Apify usage.

**Do I need to log in to any website?**
No. There are no logins, no cookies and no captchas to solve.

**How fresh is the data?**
100% real-time. Every lead is crawled live at the moment you run the Actor — never a recycled list.

**Can I export to CSV / Excel / Google Sheets / my CRM?**
Yes — export to CSV, Excel, JSON, XML, RSS, or push straight to your stack via the Apify API & integrations (HubSpot, Salesforce, Make, Zapier, n8n…).

**Will every company have an email?**
No — coverage depends on the niche and how each business publishes its data. Some return rich email + decision-maker data, others only phone + address. Turn `requireEmail` on to keep only email-bearing leads, or off for maximum volume.

**Can I scrape thousands of leads in one run?**
Yes. Increase `maxLeads` — the engine scales to thousands of companies per run.

**Is web scraping legal?**
The Actor collects publicly available business information. You are responsible for using the data in compliance with GDPR, CAN-SPAM and other applicable regulations and the target sites' terms.

***

### 🏷️ Tips for best results

- Start with `maxLeads: 100` to preview quality, then scale up.
- Use **specific sectors** (`personal injury lawyer` beats `lawyer`) for sharper targeting.
- Enable **Apify Proxy** for large runs.
- Pick **email-rich verticals** (agencies, law firms, insurance) when you need maximum named-contact emails; expect more phone/address than email in trades & local services.

***

**Ready to build your own lead database? Hit ▶️ Run and pick your sector + country.**

# Actor input Schema

## `sector` (type: `string`):

What kind of business to find. Examples: 'dentists', 'marketing agencies', 'law firms', 'plumbers', 'software companies'.

## `country` (type: `string`):

Country to target. Used for localized search and to fan out across major cities for volume. Example: 'Germany', 'United States', 'United Kingdom'.

## `cities` (type: `array`):

Limit/expand the search to specific cities. If empty, major cities of the country are used automatically for volume.

## `maxLeads` (type: `integer`):

Maximum number of distinct companies to return.

## `resultsPerQuery` (type: `integer`):

How many search results to take per query before moving on. Higher = more volume per city.

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

Home page + contact/about/team pages to crawl per company. Keep low for speed & cost.

## `maxProfilesPerSite` (type: `integer`):

From a team/attorneys listing page, how many individual people-profile pages to crawl (where names + personal emails live). Higher = more person-level leads, more cost.

## `discovery` (type: `string`):

How to find companies. 'osm' = OpenStreetMap/Overpass (recommended: thousands of results, never blocked, free). 'search' = scrape search engines (flexible but rate-limited).

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

If ON, drops companies with no email. Default OFF — keep every lead (name, phone, address, website) even without an email, for maximum volume.

## `guessEmails` (type: `boolean`):

If ON, builds likely personal emails (e.g. first.last@company.com) for named people without a listed email, using the company's detected pattern. Higher reach but lower accuracy — results are labeled 'guessed'. Default OFF for precision.

## `verifyEmails` (type: `boolean`):

Check email syntax and that the domain accepts mail (MX records). Fast and free.

## `smtpCheck` (type: `boolean`):

Try a live SMTP RCPT check per email. NOTE: outbound port 25 is usually blocked on cloud platforms, so this often returns 'unknown'. Leave off unless you run with a custom setup.

## `extraQueries` (type: `array`):

Add your own raw search queries, e.g. 'SaaS startups Berlin', to supplement sector+country.

## `extraStartUrls` (type: `array`):

Skip discovery and crawl these company websites directly (enrichment mode). Accepts domains or full URLs.

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

Proxy settings. Apify Proxy recommended to avoid search-engine rate limits.

## Actor input object example

```json
{
  "sector": "law firms",
  "country": "United Kingdom",
  "cities": [],
  "maxLeads": 200,
  "resultsPerQuery": 20,
  "maxPagesPerSite": 4,
  "maxProfilesPerSite": 8,
  "discovery": "osm",
  "requireEmail": false,
  "guessEmails": false,
  "verifyEmails": true,
  "smtpCheck": false,
  "extraQueries": [],
  "extraStartUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Companies with people, titles, phones, socials and verified emails.

# 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 = {
    "sector": "marketing agencies",
    "country": "United Kingdom",
    "cities": [],
    "extraQueries": [],
    "extraStartUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/b2b-lead-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 = {
    "sector": "marketing agencies",
    "country": "United Kingdom",
    "cities": [],
    "extraQueries": [],
    "extraStartUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/b2b-lead-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 '{
  "sector": "marketing agencies",
  "country": "United Kingdom",
  "cities": [],
  "extraQueries": [],
  "extraStartUrls": []
}' |
apify call logiover/b2b-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "B2B Lead Scraper: Emails, Phones & Decision-Makers",
        "description": "Pick a sector and country — get thousands of fresh B2B leads. Finds companies, crawls their sites for verified business emails, decision-maker names & titles, phones, address & socials, detects each company's email pattern, and verifies emails by MX. Apollo alternative — no login, no cookies.",
        "version": "0.0",
        "x-build-id": "4OlghursgVADSUlio"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~b2b-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-b2b-lead-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/logiover~b2b-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-b2b-lead-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/logiover~b2b-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-b2b-lead-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",
                "properties": {
                    "sector": {
                        "title": "Sector / Industry",
                        "type": "string",
                        "description": "What kind of business to find. Examples: 'dentists', 'marketing agencies', 'law firms', 'plumbers', 'software companies'."
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Country to target. Used for localized search and to fan out across major cities for volume. Example: 'Germany', 'United States', 'United Kingdom'."
                    },
                    "cities": {
                        "title": "Cities (optional)",
                        "type": "array",
                        "description": "Limit/expand the search to specific cities. If empty, major cities of the country are used automatically for volume.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxLeads": {
                        "title": "Max leads (companies)",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of distinct companies to return.",
                        "default": 200
                    },
                    "resultsPerQuery": {
                        "title": "Results per search query",
                        "minimum": 5,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many search results to take per query before moving on. Higher = more volume per city.",
                        "default": 20
                    },
                    "maxPagesPerSite": {
                        "title": "Max pages per website",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Home page + contact/about/team pages to crawl per company. Keep low for speed & cost.",
                        "default": 4
                    },
                    "maxProfilesPerSite": {
                        "title": "Max people-profile pages per website",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "From a team/attorneys listing page, how many individual people-profile pages to crawl (where names + personal emails live). Higher = more person-level leads, more cost.",
                        "default": 8
                    },
                    "discovery": {
                        "title": "Discovery source",
                        "enum": [
                            "osm",
                            "search"
                        ],
                        "type": "string",
                        "description": "How to find companies. 'osm' = OpenStreetMap/Overpass (recommended: thousands of results, never blocked, free). 'search' = scrape search engines (flexible but rate-limited).",
                        "default": "osm"
                    },
                    "requireEmail": {
                        "title": "Only return companies with at least one email",
                        "type": "boolean",
                        "description": "If ON, drops companies with no email. Default OFF — keep every lead (name, phone, address, website) even without an email, for maximum volume.",
                        "default": false
                    },
                    "guessEmails": {
                        "title": "Guess personal emails from name + pattern",
                        "type": "boolean",
                        "description": "If ON, builds likely personal emails (e.g. first.last@company.com) for named people without a listed email, using the company's detected pattern. Higher reach but lower accuracy — results are labeled 'guessed'. Default OFF for precision.",
                        "default": false
                    },
                    "verifyEmails": {
                        "title": "Verify emails (MX + syntax)",
                        "type": "boolean",
                        "description": "Check email syntax and that the domain accepts mail (MX records). Fast and free.",
                        "default": true
                    },
                    "smtpCheck": {
                        "title": "Deep SMTP mailbox check (best-effort)",
                        "type": "boolean",
                        "description": "Try a live SMTP RCPT check per email. NOTE: outbound port 25 is usually blocked on cloud platforms, so this often returns 'unknown'. Leave off unless you run with a custom setup.",
                        "default": false
                    },
                    "extraQueries": {
                        "title": "Extra search queries (optional)",
                        "type": "array",
                        "description": "Add your own raw search queries, e.g. 'SaaS startups Berlin', to supplement sector+country.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "extraStartUrls": {
                        "title": "Extra start URLs (optional)",
                        "type": "array",
                        "description": "Skip discovery and crawl these company websites directly (enrichment mode). Accepts domains or full URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. Apify Proxy recommended to avoid search-engine rate limits.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```