# Lead Enrichment Pipeline — Email, Firmographics & ICP (`prooflio/lead-enrichment-pipeline`) Actor

Takes raw lead lists from any source and returns deduplicated, enriched, scored records. The value-add layer that sits on top of your scrapers.

- **URL**: https://apify.com/prooflio/lead-enrichment-pipeline.md
- **Developed by:** [Prooflio AI](https://apify.com/prooflio) (community)
- **Categories:** AI, SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## Lead Enrichment Pipeline — Dedup, Email, Firmographics & ICP Scoring

**Stop re-scraping saturated sources. Be the value-add layer on top of them.**

This Actor takes raw lead lists from *any* source — the output of another scraper, a messy CSV, a domain list — and returns **deduplicated, enriched, and scored** records. Its input is a dataset, not a scrape target, so it chains on top of the commodity scrapers (Google Maps, Apollo, LinkedIn exports, etc.) instead of competing with them.

### What it does

1. **Ingests mixed sources.** Field names are auto-mapped, so `company` / `organization` / `org_name` all land on the same field. Combine inline records with the output dataset of a previous Actor run in one pass.
2. **Deduplicates / resolves entities.** Merges the same person across sources — by exact email globally, then by company + fuzzy-matched name (so "Jon" and "John" at the same company collapse into one). Field values are merged with per-field provenance so you know where each value came from.
3. **Finds & verifies emails.** Validates syntax, checks the domain's **MX records via real DNS**, and flags disposable and role-based addresses. When an email is missing, it generates ranked candidates from common corporate patterns (`first.last@`, `flast@`, …).
4. **Enriches firmographics.** Resolves industry, detected tech stack, and mail capability from the company domain. Results are **cached per domain**, so overlapping lists and re-runs don't re-pay for the same work.
5. **Scores against your ICP.** Assigns each lead a 0–100 score and an A/B/C/D tier based on industry, seniority, geography, required tech, and email quality — with the matched/missed criteria attached.

### Why this design

The margin in enrichment is in three places, and this Actor is built around all three:

- **Canonical key before enrichment.** The dedup key (domain for B2B, normalized email for people) is derived *first*, so you never pay to enrich the same entity five times under five spellings.
- **Caching.** Firmographics are keyed on domain in a key-value store. Across overlapping lists, this is often the entire difference in unit economics.
- **Free signal first.** MX/DNS checks, domain→company resolution, tech detection, and title-based seniority are all free. You can ship real enrichment before paying for a single API call.

### Input

| Field | Type | Description |
|---|---|---|
| `records` | array | Inline lead objects. Field names auto-mapped. |
| `inputDatasetId` | string | Dataset ID (e.g. a scraper's output) to load and merge. |
| `fieldMap` | object | Override/extend field aliasing (`{ "src_field": "canonicalField" }`). |
| `dedupEnabled` | boolean | Merge duplicates / resolve entities. Default `true`. |
| `fuzzyThreshold` | number | Jaro-Winkler threshold for same-company name matches. Default `0.92`. |
| `findMissingEmails` | boolean | Guess emails from name + domain. Default `true`. |
| `verifyEmails` | boolean | Syntax + MX + disposable/role checks. Default `true`. |
| `emailVerifierApiKey` | secret | Optional. Enables a mailbox-level verifier hook. |
| `enrichFirmographics` | boolean | Industry, tech stack, MX. Default `true`. |
| `fetchHomepage` | boolean | Allow homepage fetch for inference. Default `true`. |
| `firmographicsApiKey` | secret | Optional. Enables a paid firmographics provider hook. |
| `icp` | object | Scoring config (industries, seniority, countries, required tech, weights). |
| `suppressionList` | array | Emails/domains to drop (opt-outs, competitors). |
| `maxRecords` | integer | Cap input after loading (`0` = no limit). |
| `maxConcurrency` | integer | Parallel enrichment workers. Default `10`. |
| `proxyConfiguration` | object | Proxy for homepage fetches (recommended on platform). |

#### Example input

```json
{
  "inputDatasetId": "YOUR_SCRAPER_OUTPUT_DATASET_ID",
  "records": [
    { "name": "Jane Doe", "title": "VP Engineering", "company": "Acme, Inc.", "website": "https://acme.com" }
  ],
  "icp": {
    "targetIndustries": ["software", "saas"],
    "seniorityKeywords": ["vp", "head", "chief", "director", "founder"],
    "targetCountries": ["United States"],
    "requiredTech": ["HubSpot"]
  },
  "suppressionList": ["competitor.com", "optout@example.com"]
}
````

### Output

Each dataset record is a flattened, enriched lead. Key fields:

- Identity: `fullName`, `firstName`, `lastName`, `jobTitle`, `companyName`, `domain`, `website`, `country`, `phone`, `linkedinUrl`
- Email: `email`, `emailStatus` (`deliverable` / `risky` / `undeliverable` / `unknown`), `emailIsGuessed`, `emailIsRoleBased`, `emailIsDisposable`, `emailConfidence`, `emailCandidates`
- Firmographics: `industry`, `techStack`, `firmographicsSource`
- Scoring: `icpScore`, `icpTier`, `icpMatched`, `icpMissed`
- Provenance: `mergedRecordCount`, `sources`, `provenance` (field → source), `extra` (unmapped passthrough)

Records are sorted best-first by `icpScore`. A run-level `SUMMARY` (input/unique counts, tier and email-status breakdowns) is written to the default key-value store.

### Limitations (by design)

- **Email verification is not mailbox-level** without a provider hook. `deliverable` means valid syntax + a real MX record + not role/disposable — it does not confirm the specific mailbox exists. Guessed emails are always flagged `emailIsGuessed: true` and kept at low confidence.
- **Domain parsing is hostname-level**, not eTLD+1 (no public-suffix list). This is reliable for the vast majority of B2B domains.
- **Free firmographics are inferred** from DNS and homepage signals. Headcount/revenue require a paid provider via the hook.

### Compliance

Lead data is personal data. This Actor carries a per-field `source`/provenance trail and supports a `suppressionList` for opt-outs from the first run. You are responsible for ensuring your use complies with GDPR, CCPA, and the terms of the sources you feed it. Do not process personal data without a lawful basis.

# Actor input Schema

## `records` (type: `array`):

Raw lead objects to process. Field names are auto-mapped (e.g. company / organization / companyName all map to companyName). Combine with 'inputDatasetId' to merge sources.

## `inputDatasetId` (type: `string`):

ID of an existing dataset (e.g. the output of a scraper Actor) whose items are loaded as leads and merged with any inline records. This is the 'chain on top of your scrapers' input.

## `fieldMap` (type: `object`):

Override or extend the default field aliasing. Keys are source field names, values are one of: fullName, firstName, lastName, jobTitle, email, phone, linkedinUrl, companyName, website, country, city, source.

## `dedupEnabled` (type: `boolean`):

Merge duplicate leads (same email globally, or same company + fuzzy-matched name). Field values are merged with provenance tracking.

## `fuzzyThreshold` (type: `number`):

Jaro-Winkler similarity (0-1) above which two names within the same company are treated as the same person. Higher = stricter.

## `findMissingEmails` (type: `boolean`):

When a lead has a name + company domain but no email, generate ranked candidate addresses from common patterns (first.last@, flast@, etc.). Guessed emails are flagged isGuessed=true and never claimed as verified.

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

Validate syntax, check the domain's MX records (real DNS lookup), and flag disposable / role-based addresses. Mailbox-level (SMTP) verification requires a provider — see emailVerifierApiKey.

## `emailVerifierApiKey` (type: `string`):

Optional. If set, enables mailbox-level verification via your provider hook in src/email.ts (e.g. ZeroBounce, NeverBounce). Leave empty to use free MX + heuristic verification only.

## `enrichFirmographics` (type: `boolean`):

Resolve company-level attributes from the domain: industry classification, detected tech stack, and MX presence. Results are cached per domain so overlapping lists don't re-pay.

## `fetchHomepage` (type: `boolean`):

Allow firmographics to fetch the company homepage to infer industry and detect tech signals. Disable for a faster, network-free run that uses only DNS-level signals.

## `firmographicsApiKey` (type: `string`):

Optional. If set, enables your paid firmographics provider hook in src/firmographics.ts (e.g. People Data Labs, Clearbit) for headcount, revenue, etc. Leave empty to use free inference only.

## `icp` (type: `object`):

Defines how each enriched lead is scored 0-100. Omit to skip scoring.

## `suppressionList` (type: `array`):

Emails or domains to drop entirely (compliance / opt-outs / competitors). Matching leads are excluded from the output.

## `maxRecords` (type: `integer`):

Hard cap on input records after loading (0 = no limit). Useful for test runs.

## `maxConcurrency` (type: `integer`):

Parallel enrichment workers. Keep modest when fetching homepages to be polite.

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

Proxy used when fetching company homepages. Recommended on the platform to avoid blocks.

## Actor input object example

```json
{
  "records": [
    {
      "fullName": "Jane Doe",
      "title": "VP Engineering",
      "company": "Acme, Inc.",
      "website": "https://acme.com"
    },
    {
      "name": "Jane Doe",
      "jobTitle": "VP of Engineering",
      "organization": "Acme Inc",
      "email": "jane.doe@acme.com"
    }
  ],
  "fieldMap": {
    "org_name": "companyName",
    "work_email": "email"
  },
  "dedupEnabled": true,
  "fuzzyThreshold": 0.92,
  "findMissingEmails": true,
  "verifyEmails": true,
  "enrichFirmographics": true,
  "fetchHomepage": true,
  "icp": {
    "targetIndustries": [
      "software",
      "saas"
    ],
    "targetCountries": [
      "United States",
      "US"
    ],
    "requiredTech": [],
    "seniorityKeywords": [
      "head",
      "vp",
      "chief",
      "director",
      "founder"
    ]
  },
  "suppressionList": [],
  "maxRecords": 0,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `enrichedLeads` (type: `string`):

Dataset of processed leads with email verification, firmographics, and ICP scores.

## `runSummary` (type: `string`):

Aggregate counts (input, deduped, scored by tier) for this run.

# 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 = {
    "records": [
        {
            "fullName": "Jane Doe",
            "title": "VP Engineering",
            "company": "Acme, Inc.",
            "website": "https://acme.com"
        },
        {
            "name": "Jane Doe",
            "jobTitle": "VP of Engineering",
            "organization": "Acme Inc",
            "email": "jane.doe@acme.com"
        }
    ],
    "fieldMap": {
        "org_name": "companyName",
        "work_email": "email"
    },
    "icp": {
        "targetIndustries": [
            "software",
            "saas"
        ],
        "targetCountries": [
            "United States",
            "US"
        ],
        "requiredTech": [],
        "seniorityKeywords": [
            "head",
            "vp",
            "chief",
            "director",
            "founder"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("prooflio/lead-enrichment-pipeline").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 = {
    "records": [
        {
            "fullName": "Jane Doe",
            "title": "VP Engineering",
            "company": "Acme, Inc.",
            "website": "https://acme.com",
        },
        {
            "name": "Jane Doe",
            "jobTitle": "VP of Engineering",
            "organization": "Acme Inc",
            "email": "jane.doe@acme.com",
        },
    ],
    "fieldMap": {
        "org_name": "companyName",
        "work_email": "email",
    },
    "icp": {
        "targetIndustries": [
            "software",
            "saas",
        ],
        "targetCountries": [
            "United States",
            "US",
        ],
        "requiredTech": [],
        "seniorityKeywords": [
            "head",
            "vp",
            "chief",
            "director",
            "founder",
        ],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("prooflio/lead-enrichment-pipeline").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 '{
  "records": [
    {
      "fullName": "Jane Doe",
      "title": "VP Engineering",
      "company": "Acme, Inc.",
      "website": "https://acme.com"
    },
    {
      "name": "Jane Doe",
      "jobTitle": "VP of Engineering",
      "organization": "Acme Inc",
      "email": "jane.doe@acme.com"
    }
  ],
  "fieldMap": {
    "org_name": "companyName",
    "work_email": "email"
  },
  "icp": {
    "targetIndustries": [
      "software",
      "saas"
    ],
    "targetCountries": [
      "United States",
      "US"
    ],
    "requiredTech": [],
    "seniorityKeywords": [
      "head",
      "vp",
      "chief",
      "director",
      "founder"
    ]
  }
}' |
apify call prooflio/lead-enrichment-pipeline --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lead Enrichment Pipeline — Email, Firmographics & ICP",
        "description": "Takes raw lead lists from any source and returns deduplicated, enriched, scored records. The value-add layer that sits on top of your scrapers.",
        "version": "1.0",
        "x-build-id": "LRgLLfsj1ZH9KseKZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/prooflio~lead-enrichment-pipeline/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-prooflio-lead-enrichment-pipeline",
                "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/prooflio~lead-enrichment-pipeline/runs": {
            "post": {
                "operationId": "runs-sync-prooflio-lead-enrichment-pipeline",
                "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/prooflio~lead-enrichment-pipeline/run-sync": {
            "post": {
                "operationId": "run-sync-prooflio-lead-enrichment-pipeline",
                "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": {
                    "records": {
                        "title": "Inline lead records",
                        "type": "array",
                        "description": "Raw lead objects to process. Field names are auto-mapped (e.g. company / organization / companyName all map to companyName). Combine with 'inputDatasetId' to merge sources."
                    },
                    "inputDatasetId": {
                        "title": "Input dataset ID",
                        "type": "string",
                        "description": "ID of an existing dataset (e.g. the output of a scraper Actor) whose items are loaded as leads and merged with any inline records. This is the 'chain on top of your scrapers' input."
                    },
                    "fieldMap": {
                        "title": "Custom field mapping",
                        "type": "object",
                        "description": "Override or extend the default field aliasing. Keys are source field names, values are one of: fullName, firstName, lastName, jobTitle, email, phone, linkedinUrl, companyName, website, country, city, source."
                    },
                    "dedupEnabled": {
                        "title": "Deduplicate / resolve entities",
                        "type": "boolean",
                        "description": "Merge duplicate leads (same email globally, or same company + fuzzy-matched name). Field values are merged with provenance tracking.",
                        "default": true
                    },
                    "fuzzyThreshold": {
                        "title": "Fuzzy name match threshold",
                        "minimum": 0.5,
                        "maximum": 1,
                        "type": "number",
                        "description": "Jaro-Winkler similarity (0-1) above which two names within the same company are treated as the same person. Higher = stricter.",
                        "default": 0.92
                    },
                    "findMissingEmails": {
                        "title": "Guess missing emails",
                        "type": "boolean",
                        "description": "When a lead has a name + company domain but no email, generate ranked candidate addresses from common patterns (first.last@, flast@, etc.). Guessed emails are flagged isGuessed=true and never claimed as verified.",
                        "default": true
                    },
                    "verifyEmails": {
                        "title": "Verify emails",
                        "type": "boolean",
                        "description": "Validate syntax, check the domain's MX records (real DNS lookup), and flag disposable / role-based addresses. Mailbox-level (SMTP) verification requires a provider — see emailVerifierApiKey.",
                        "default": true
                    },
                    "emailVerifierApiKey": {
                        "title": "Email verifier API key (optional)",
                        "type": "string",
                        "description": "Optional. If set, enables mailbox-level verification via your provider hook in src/email.ts (e.g. ZeroBounce, NeverBounce). Leave empty to use free MX + heuristic verification only."
                    },
                    "enrichFirmographics": {
                        "title": "Enrich firmographics",
                        "type": "boolean",
                        "description": "Resolve company-level attributes from the domain: industry classification, detected tech stack, and MX presence. Results are cached per domain so overlapping lists don't re-pay.",
                        "default": true
                    },
                    "fetchHomepage": {
                        "title": "Fetch company homepage",
                        "type": "boolean",
                        "description": "Allow firmographics to fetch the company homepage to infer industry and detect tech signals. Disable for a faster, network-free run that uses only DNS-level signals.",
                        "default": true
                    },
                    "firmographicsApiKey": {
                        "title": "Firmographics provider API key (optional)",
                        "type": "string",
                        "description": "Optional. If set, enables your paid firmographics provider hook in src/firmographics.ts (e.g. People Data Labs, Clearbit) for headcount, revenue, etc. Leave empty to use free inference only."
                    },
                    "icp": {
                        "title": "Ideal Customer Profile (scoring config)",
                        "type": "object",
                        "description": "Defines how each enriched lead is scored 0-100. Omit to skip scoring."
                    },
                    "suppressionList": {
                        "title": "Suppression list",
                        "type": "array",
                        "description": "Emails or domains to drop entirely (compliance / opt-outs / competitors). Matching leads are excluded from the output.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxRecords": {
                        "title": "Max records to process",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on input records after loading (0 = no limit). Useful for test runs.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Parallel enrichment workers. Keep modest when fetching homepages to be polite.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used when fetching company homepages. Recommended on the platform to avoid blocks.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
