# Email Pattern Finder (`automation-lab/email-pattern-finder`) Actor

Infer company email formats from known contacts and generate scored candidate work emails for B2B lead enrichment workflows.

- **URL**: https://apify.com/automation-lab/email-pattern-finder.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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.
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

## Email Pattern Finder

Infer company email formats from known contacts, check the domain, and generate candidate work emails for your target prospects.

Email Pattern Finder is a deterministic B2B lead-generation utility. Give it one or more company domains, a few known employee emails, and the names of people you want to contact. The actor detects patterns such as `first.last`, `flast`, `firstl`, or `first_last`, scores the evidence, checks DNS/MX records, and returns candidate email addresses with confidence and warnings.

### What does Email Pattern Finder do?

It turns partial lead data into structured candidate emails.

- 🧩 Detects common corporate email patterns from sample contacts
- 🎯 Generates candidate emails for target people
- 📈 Scores confidence from the evidence you provide
- 📨 Checks whether the domain has MX records
- ⚠️ Flags weak evidence, missing samples, and DNS problems
- 🔒 Avoids SMTP probing, credential use, and paid enrichment APIs

### Who is it for?

Sales operations teams use it to prepare outreach lists before sending rows to an email verifier.

Recruiters use it to infer likely work emails for candidates at a target employer.

Lead-generation agencies use it to enrich prospect spreadsheets when they already have a few known company contacts.

RevOps teams use it as a repeatable step between company/person sourcing and downstream verification.

### Why use this actor?

Many enrichment tools hide the pattern logic. This actor exposes the evidence, pattern, confidence score, generated candidates, and warnings in the dataset. You can decide whether a row is strong enough for your workflow.

### When should you use it?

Use it when you have:

- a company domain,
- at least one known employee email for that domain,
- target first and last names,
- and a downstream process for verification or manual review.

### What it does not do

This actor does not send email. It does not log in to any service. It does not perform SMTP mailbox probing. It does not guarantee that a mailbox exists. It generates likely candidate addresses from observable patterns and domain DNS signals.

### Data returned

| Field | Description |
| --- | --- |
| `domain` | Company domain used for the generated candidates |
| `targetFullName` | Target person name |
| `detectedPatterns` | Ranked patterns found in sample contacts |
| `topPattern` | Highest-confidence pattern used first |
| `confidenceScore` | Score from 0 to 1 |
| `evidenceCount` | Number of sample contacts matching detected patterns |
| `generatedEmails` | Candidate emails with pattern and MX metadata |
| `domainHasMx` | Whether DNS MX records were found |
| `warnings` | Data-quality or confidence warnings |
| `sourceRows` | Optional sample source metadata |

### How much does it cost to find email patterns?

The actor uses pay-per-event pricing: a small start event plus a per-result event for each generated target row. Keep the default prefill small while testing. Larger batches are efficient because the actor performs deterministic local pattern matching and reuses DNS checks per domain.

### Input

The main input fields are:

- `domains` — optional domains such as `stripe.com`.
- `sampleContacts` — known emails with names.
- `targetContacts` — people you want candidate emails for.
- `confidenceThreshold` — minimum score for using detected patterns.
- `maxGuessesPerPerson` — candidate cap per target.
- `validateMx` — enables DNS/MX checks.

### Example input

```json
{
  "domains": ["stripe.com"],
  "sampleContacts": [
    { "email": "john.doe@stripe.com", "firstName": "John", "lastName": "Doe" },
    { "email": "jane.smith@stripe.com", "firstName": "Jane", "lastName": "Smith" }
  ],
  "targetContacts": [
    { "fullName": "Alex Taylor", "domain": "stripe.com", "sourceId": "lead-001" }
  ],
  "confidenceThreshold": 0.25,
  "maxGuessesPerPerson": 5,
  "validateMx": true
}
````

### Example output

```json
{
  "domain": "stripe.com",
  "targetFullName": "Alex Taylor",
  "topPattern": "first.last",
  "confidenceScore": 1,
  "evidenceCount": 2,
  "generatedEmails": [
    {
      "email": "alex.taylor@stripe.com",
      "pattern": "first.last",
      "confidence": 1,
      "syntaxValid": true,
      "domainHasMx": true
    }
  ],
  "warnings": []
}
```

### How to run it

1. Open the actor on Apify.
2. Paste known sample contacts.
3. Add target contacts and domains.
4. Keep `validateMx` enabled unless you need offline-only generation.
5. Run the actor.
6. Export the dataset to JSON, CSV, Excel, or via API.

### Tips for best results

Use at least two or three known emails per domain when possible.

Prefer real first and last names over initials.

Keep aliases such as `support@`, `info@`, and `sales@` out of the sample rows because they do not represent employee name patterns.

Set `includeLowConfidencePatterns` only when you want to inspect weak alternatives.

### Handling weak evidence

If no sample matches a known pattern, the actor falls back to `first.last` and adds a warning. This gives you a useful candidate while making it clear that the result is not evidence-backed.

### Supported patterns

The actor checks common formats including:

- `first`
- `last`
- `firstlast`
- `first.last`
- `first_last`
- `first-last`
- `flast`
- `f.last`
- `f_last`
- `firstl`
- `first.l`
- `lastfirst`
- `last.first`
- `lastf`

### Integrations

Use the actor in lead workflows such as:

- company list scraper → Email Pattern Finder → email verifier → CRM
- recruiter target list → Email Pattern Finder → manual review
- inbound account list → Email Pattern Finder → sales engagement platform
- Apify dataset export → Google Sheets or Airtable enrichment

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/email-pattern-finder').call({
  domains: ['stripe.com'],
  sampleContacts: [{ email: 'john.doe@stripe.com', firstName: 'John', lastName: 'Doe' }],
  targetContacts: [{ fullName: 'Alex Taylor', domain: 'stripe.com' }]
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient()
run = client.actor('automation-lab/email-pattern-finder').call(run_input={
    'domains': ['stripe.com'],
    'sampleContacts': [{'email': 'john.doe@stripe.com', 'firstName': 'John', 'lastName': 'Doe'}],
    'targetContacts': [{'fullName': 'Alex Taylor', 'domain': 'stripe.com'}],
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~email-pattern-finder/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"domains":["stripe.com"],"sampleContacts":[{"email":"john.doe@stripe.com","firstName":"John","lastName":"Doe"}],"targetContacts":[{"fullName":"Alex Taylor","domain":"stripe.com"}]}'
```

### MCP usage

Connect Apify MCP with this actor enabled:

`https://mcp.apify.com/?tools=automation-lab/email-pattern-finder`

Claude Code setup:

```bash
claude mcp add apify-email-pattern-finder https://mcp.apify.com/?tools=automation-lab/email-pattern-finder
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-email-pattern-finder": {
      "url": "https://mcp.apify.com/?tools=automation-lab/email-pattern-finder"
    }
  }
}
```

Cursor setup:

1. Open **Cursor Settings → MCP**.
2. Add a new remote server named `apify-email-pattern-finder`.
3. Use this URL: `https://mcp.apify.com/?tools=automation-lab/email-pattern-finder`.
4. Save, reconnect the MCP server, then ask Cursor to run the Email Pattern Finder tool with your lead list input.

VS Code setup:

1. Install or enable an MCP-compatible assistant extension in VS Code.
2. Add a remote MCP server named `apify-email-pattern-finder` with URL `https://mcp.apify.com/?tools=automation-lab/email-pattern-finder`.
3. Confirm the Apify MCP server appears as connected before sending prompts that include domains, sample contacts, and target contacts.

Example prompts:

- "Find the likely email pattern for this domain from these sample contacts."
- "Generate candidate emails for these prospects and flag weak evidence."
- "Convert this CSV-style lead list into Email Pattern Finder input."

### Legality and privacy

This actor only processes data you provide and public DNS records. It does not bypass login walls, scrape inboxes, probe mailboxes, or send messages. You are responsible for using generated candidates in compliance with applicable privacy, employment, anti-spam, and outreach laws.

### FAQ and troubleshooting

#### Why did I get only first.last candidates?

The actor did not find enough sample evidence above your confidence threshold. Add more known employee emails or enable low-confidence patterns for inspection.

#### Why is `domainHasMx` false?

The domain may not receive email, or the DNS lookup may have failed during the run. You can disable MX checks if you only need deterministic generation.

#### Why was a target skipped?

Each target needs a first and last name, either as `firstName` and `lastName` or as a parseable `fullName`.

### Related actors

- [Email Finder](https://apify.com/automation-lab/email-finder)
- [Email Enrichment](https://apify.com/automation-lab/email-enrichment)
- [Website Contact Finder](https://apify.com/automation-lab/website-contact-finder)
- [B2B URL Finder](https://apify.com/automation-lab/b2b-url-finder)

### Changelog

Initial version: deterministic pattern detection, DNS/MX checks, confidence scoring, and candidate generation.

### Support

If you need a new pattern, output field, or batch format, open an issue from the Apify actor page and include a small anonymized input sample.

# Actor input Schema

## `domains` (type: `array`):

Optional list of company domains. Domains can also be inferred from sample email addresses or target rows.

## `sampleContacts` (type: `array`):

Known employee emails with names. The actor uses these rows to detect the organization's email format.

## `targetContacts` (type: `array`):

People to generate candidate work emails for. Include first/last name or fullName; domain is optional when you provide domains above.

## `confidenceThreshold` (type: `number`):

Patterns below this confidence are filtered unless Include low-confidence patterns is enabled.

## `maxGuessesPerPerson` (type: `integer`):

Maximum candidate email addresses to generate for each target contact.

## `validateMx` (type: `boolean`):

Verify whether each domain has MX records. This does not perform SMTP probing or send email.

## `includeLowConfidencePatterns` (type: `boolean`):

When enabled, keep detected patterns even if they are below the confidence threshold.

## Actor input object example

```json
{
  "domains": [
    "stripe.com"
  ],
  "sampleContacts": [
    {
      "email": "john.doe@stripe.com",
      "firstName": "John",
      "lastName": "Doe",
      "source": "crm-row-101"
    },
    {
      "email": "jane.smith@stripe.com",
      "firstName": "Jane",
      "lastName": "Smith",
      "source": "crm-row-102"
    }
  ],
  "targetContacts": [
    {
      "fullName": "Alex Taylor",
      "domain": "stripe.com",
      "sourceId": "lead-001"
    },
    {
      "firstName": "Morgan",
      "lastName": "Lee",
      "domain": "stripe.com",
      "sourceId": "lead-002"
    }
  ],
  "confidenceThreshold": 0.25,
  "maxGuessesPerPerson": 5,
  "validateMx": true,
  "includeLowConfidencePatterns": false
}
```

# Actor output Schema

## `emailCandidates` (type: `string`):

No description

# 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 = {
    "domains": [
        "stripe.com"
    ],
    "sampleContacts": [
        {
            "email": "john.doe@stripe.com",
            "firstName": "John",
            "lastName": "Doe",
            "source": "crm-row-101"
        },
        {
            "email": "jane.smith@stripe.com",
            "firstName": "Jane",
            "lastName": "Smith",
            "source": "crm-row-102"
        }
    ],
    "targetContacts": [
        {
            "fullName": "Alex Taylor",
            "domain": "stripe.com",
            "sourceId": "lead-001"
        },
        {
            "firstName": "Morgan",
            "lastName": "Lee",
            "domain": "stripe.com",
            "sourceId": "lead-002"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/email-pattern-finder").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 = {
    "domains": ["stripe.com"],
    "sampleContacts": [
        {
            "email": "john.doe@stripe.com",
            "firstName": "John",
            "lastName": "Doe",
            "source": "crm-row-101",
        },
        {
            "email": "jane.smith@stripe.com",
            "firstName": "Jane",
            "lastName": "Smith",
            "source": "crm-row-102",
        },
    ],
    "targetContacts": [
        {
            "fullName": "Alex Taylor",
            "domain": "stripe.com",
            "sourceId": "lead-001",
        },
        {
            "firstName": "Morgan",
            "lastName": "Lee",
            "domain": "stripe.com",
            "sourceId": "lead-002",
        },
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/email-pattern-finder").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 '{
  "domains": [
    "stripe.com"
  ],
  "sampleContacts": [
    {
      "email": "john.doe@stripe.com",
      "firstName": "John",
      "lastName": "Doe",
      "source": "crm-row-101"
    },
    {
      "email": "jane.smith@stripe.com",
      "firstName": "Jane",
      "lastName": "Smith",
      "source": "crm-row-102"
    }
  ],
  "targetContacts": [
    {
      "fullName": "Alex Taylor",
      "domain": "stripe.com",
      "sourceId": "lead-001"
    },
    {
      "firstName": "Morgan",
      "lastName": "Lee",
      "domain": "stripe.com",
      "sourceId": "lead-002"
    }
  ]
}' |
apify call automation-lab/email-pattern-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Email Pattern Finder",
        "description": "Infer company email formats from known contacts and generate scored candidate work emails for B2B lead enrichment workflows.",
        "version": "0.1",
        "x-build-id": "Tp1CPCQeSmR0DRZtA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~email-pattern-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-email-pattern-finder",
                "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/automation-lab~email-pattern-finder/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-email-pattern-finder",
                "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/automation-lab~email-pattern-finder/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-email-pattern-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "sampleContacts",
                    "targetContacts"
                ],
                "properties": {
                    "domains": {
                        "title": "Company domains",
                        "type": "array",
                        "description": "Optional list of company domains. Domains can also be inferred from sample email addresses or target rows.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sampleContacts": {
                        "title": "Known sample contacts",
                        "type": "array",
                        "description": "Known employee emails with names. The actor uses these rows to detect the organization's email format."
                    },
                    "targetContacts": {
                        "title": "Target contacts",
                        "type": "array",
                        "description": "People to generate candidate work emails for. Include first/last name or fullName; domain is optional when you provide domains above."
                    },
                    "confidenceThreshold": {
                        "title": "Minimum pattern confidence",
                        "minimum": 0,
                        "maximum": 1,
                        "type": "number",
                        "description": "Patterns below this confidence are filtered unless Include low-confidence patterns is enabled.",
                        "default": 0.25
                    },
                    "maxGuessesPerPerson": {
                        "title": "Maximum guesses per person",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum candidate email addresses to generate for each target contact.",
                        "default": 5
                    },
                    "validateMx": {
                        "title": "Check DNS/MX records",
                        "type": "boolean",
                        "description": "Verify whether each domain has MX records. This does not perform SMTP probing or send email.",
                        "default": true
                    },
                    "includeLowConfidencePatterns": {
                        "title": "Include low-confidence patterns",
                        "type": "boolean",
                        "description": "When enabled, keep detected patterns even if they are below the confidence threshold.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```