# Website Email Scraper & Phone Finder ✅ $2/1k (`x_guru/website-email-phone-finder`) Actor

From $2.00 / 1,000 saved results. Website email scraper and domain email finder for lead generation: public business emails, phones, social profiles, source URLs, and contact-page diagnostics from domains.

- **URL**: https://apify.com/x\_guru/website-email-phone-finder.md
- **Developed by:** [Hundevmode Labs](https://apify.com/x_guru) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 saved website contact 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

## Website Email Scraper & Phone Finder: Scrape Emails, Phones & Socials from Domains

From **$2.00 / 1,000 saved website contact results** on paid Apify plans. Use this **website email scraper** and **website email finder** for lead generation: scan domains or website URLs and extract public business emails, phone numbers, social media profiles, source URLs, and crawl diagnostics.

This actor is built as a fast **domain email scraper**, **email phone finder**, and domain contact enrichment tool. Paste a list of websites, run a fast shallow crawl, and get one clean contact record per matching website. It checks the homepage or supplied URL, follows likely contact/about/legal/team pages, extracts public contacts, and saves only websites with emails by default.

Use it when you already have domains from Google Maps, CRMs, spreadsheets, directories, search results, company databases, or lead lists and need public contact details from each website.

### AI agent skill

Use the dedicated [Website Email Scraper Apify agent skill](https://github.com/hundevmode/apify-website-email-scraper-agent-skill) when you want AI agents to normalize domain lists, run this actor through Apify, control spend with `maxTotalChargeUsd`, and return public website email/contact rows for outreach, CRM, Sheets, n8n, BI, or enrichment workflows.

Install with skills.sh-compatible agents:

```bash
npx skills add hundevmode/apify-website-email-scraper-agent-skill \
  --skill website-email-scraper-apify
````

ClawHub skill slug: `website-email-scraper-apify`.

### At a glance

| Need | Use this actor for |
| --- | --- |
| Domain email scraping | Find public emails from company websites |
| Website email finder | Turn domains and website URLs into structured email lead records |
| Website email scraper | Crawl homepage, contact, about, team, legal, and imprint pages for public emails |
| Lead generation | Enrich existing website lists with outreach-ready business contact details |
| Sales enrichment | Add emails, phones, and socials to existing domain lists |
| CRM cleanup | Convert raw domains into structured contact records |
| Agency prospecting | Scan niche website lists collected from Google Maps, directories, or search results |
| Bulk export | Download contacts as JSON, CSV, Excel, or through the Apify API |

### Quick start

Start with a list of domains. The actor accepts bare domains and full URLs in the same input field.

```json
{
  "domains": [
    "centralrestaurante.com",
    "alchemist.dk",
    "caitlinmcweeney.com"
  ],
  "maxResults": 1000,
  "resultMode": "emailsOnly",
  "maxPagesPerWebsite": 3,
  "concurrency": 100,
  "extractPhones": true,
  "extractSocials": true,
  "includePersonalData": true
}
```

### Pricing

The actor uses Apify pay-per-event pricing. The primary event is `website-contact-saved`, charged when a website contact result is saved to the dataset.

| Event | Free | Paid plans |
| --- | --- | --- |
| Saved website contact result | $5.00 / 1,000 saved results | $2.00 / 1,000 saved results |
| Actor start | $0.00005 per start event | $0.00001 per start event |

Scanned websites that do not match the selected result mode are not charged as saved contact results. The actor respects Apify `maxTotalChargeUsd` and stops before saving more paid results than the run budget allows.

### What it extracts

| Data group | Example fields |
| --- | --- |
| Website identity | `input`, `url`, `domain`, `status` |
| Emails | `emails`, `emailDetails.email`, `emailDetails.type`, `emailDetails.sourceUrl`, `emailDetails.domainMatch` |
| Phones | `phones` |
| Social links | `facebooks`, `instagrams`, `linkedIns`, `twitters`, `youtubes`, `tiktoks`, `socialLinks` |
| Crawl diagnostics | `pagesFetched`, `fetchedUrls`, `httpStatusCodes`, `errors`, `durationMs` |
| Contact counts | `contactSignals.emails`, `contactSignals.phones`, `contactSignals.socialProfiles`, `contactSignals.pagesFetched` |

This website email scraper saves normalized contact records that are easy to export to CSV, Excel, JSON, CRM tools, sales workflows, enrichment pipelines, and agent workflows.

Email types:

| Type | Meaning |
| --- | --- |
| `role` | Generic company inbox such as `info@`, `sales@`, `hello@`, or `contact@` |
| `personal` | Person-like email found on a public website |
| `unknown` | Public email that is not clearly role-based or person-like |

### Input options

#### Domains or URLs

Use `domains` for domains and URLs. Both formats are accepted:

```json
{
  "domains": [
    "example.com",
    "https://example.com/contact"
  ]
}
```

The actor tries HTTPS, WWW, and HTTP variants when needed.

For bulk domain email scraping, paste one domain per row. For exact-page extraction, paste full URLs such as contact pages, about pages, or company profile pages.

#### Result mode

| Mode | Saved dataset items |
| --- | --- |
| `emailsOnly` | Only websites where at least one public email was found. This is the default. |
| `contactsOnly` | Websites with at least one email, phone, or social profile. |
| `allWebsites` | All scanned websites, including websites where no contact was found. |

#### Crawl depth and speed

| Field | What it does |
| --- | --- |
| `maxPagesPerWebsite` | Number of pages to fetch per website. Default is 3. |
| `concurrency` | Number of websites scanned in parallel. Default is 100. |
| `requestTimeoutSecs` | Per-page timeout. Default is 5 seconds. |
| `sameDomainOnly` | Follow only same-domain contact/about links. Social links are still extracted. |

The actor prioritizes URLs containing contact, about, team, staff, impressum, imprint, legal, privacy, and similar contact-page hints.

#### Contact fields

| Field | What it does |
| --- | --- |
| `extractPhones` | Extract phone numbers from visible text and `tel:` links. |
| `extractSocials` | Extract public social media profile links. |
| `includePersonalData` | Include person-like emails and personal LinkedIn URLs when found on public websites. |

### How it works

1. Normalizes every domain or URL.
2. Tries HTTPS, WWW, and HTTP variants when needed.
3. Downloads HTML with a Chrome-like HTTP client optimized for high concurrency.
4. Extracts emails, phones, `mailto:`, `tel:`, and social profile links.
5. Scores internal links and follows the best contact/about/legal/team pages.
6. Applies `resultMode`.
7. Saves one dataset item per matching website using the PPE result event.
8. Writes `RUN_SUMMARY` with processed count, saved count, filters, and budget guard details.

The default path is HTTP-first and browserless for speed. It uses a Chrome-like HTTP client with high concurrency, so large domain lists can run faster than browser-first website contact scrapers.

### Output example

```json
{
  "input": "caitlinmcweeney.com",
  "url": "https://caitlinmcweeney.com/",
  "domain": "caitlinmcweeney.com",
  "status": "found",
  "emails": ["caitlin@caitlinmcweeney.com"],
  "emailDetails": [
    {
      "email": "caitlin@caitlinmcweeney.com",
      "type": "unknown",
      "sourceUrl": "https://caitlinmcweeney.com/contact",
      "domainMatch": true
    }
  ],
  "phones": [],
  "facebooks": ["https://www.facebook.com/caitlinmcweeneyphotography"],
  "instagrams": ["https://www.instagram.com/caitlinmcweeneyphotography/"],
  "contactSignals": {
    "emails": 1,
    "phones": 0,
    "socialProfiles": 2,
    "pagesFetched": 2
  },
  "pagesFetched": 2,
  "fetchedUrls": [
    "https://caitlinmcweeney.com/",
    "https://caitlinmcweeney.com/contact"
  ],
  "durationMs": 1530
}
```

### Run summary

Every run writes `RUN_SUMMARY` to the default key-value store.

Useful fields:

| Field | Meaning |
| --- | --- |
| `inputWebsites` | Number of submitted websites |
| `processed` | Number of websites scanned |
| `saved` | Number of saved dataset items |
| `filteredOut` | Websites scanned but not saved due to result mode |
| `failed` | Websites that could not be fetched |
| `chargeLimitReached` | Whether Apify PPE budget stopped the run |
| `exhaustionReason` | `target_reached`, `input_exhausted`, or `charge_limit_reached` |

### API usage

```bash
curl -X POST "https://api.apify.com/v2/acts/x_guru~website-email-phone-finder/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "domains": ["example.com", "apify.com"],
    "resultMode": "emailsOnly",
    "maxPagesPerWebsite": 3,
    "concurrency": 100,
    "extractPhones": true,
    "extractSocials": true
  }'
```

### Tips

- Use `emailsOnly` for paid email lead extraction and website email scraping.
- Use `contactsOnly` if phones and social profiles are useful even when no email is found.
- Increase `maxPagesPerWebsite` to 5-10 for sites where emails are hidden on team, staff, legal, or imprint pages.
- Keep `requestTimeoutSecs` low for large batches so slow websites do not block throughput.
- Set an Apify maximum cost per run when processing very large domain lists.

### Common searches this actor covers

- website email scraper
- website email finder
- domain email scraper
- domain contact finder
- email phone finder
- business email scraper
- company email finder
- website contact scraper

# Actor input Schema

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

Domains or full website URLs to scan. You can paste domains such as example.com or URLs such as https://example.com/contact.

## `maxResults` (type: `integer`):

Maximum number of saved website contact results. In Emails only mode, websites without emails are scanned but not saved.

## `resultMode` (type: `string`):

Choose what should be saved to the dataset.

## `maxPagesPerWebsite` (type: `integer`):

How many pages to fetch from each website. The actor starts with the homepage or supplied URL, then follows likely contact/about/legal/team pages.

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

How many websites to scan in parallel. Increase for large lists; decrease if many websites throttle requests.

## `requestTimeoutSecs` (type: `integer`):

Per-page timeout. Short timeouts keep large batches moving quickly.

## `extractPhones` (type: `boolean`):

Extract public phone numbers from visible page text and tel: links.

## `extractSocials` (type: `boolean`):

Extract public Facebook, Instagram, LinkedIn, X/Twitter, YouTube, and TikTok profile links.

## `includePersonalData` (type: `boolean`):

Enable person-like emails and personal LinkedIn profile URLs found on public websites. Disable to keep mostly generic company inboxes.

## `sameDomainOnly` (type: `boolean`):

Only follow contact/about links on the same root domain. Social profile links are still extracted.

## Actor input object example

```json
{
  "domains": [
    "centralrestaurante.com",
    "alchemist.dk",
    "caitlinmcweeney.com"
  ],
  "maxResults": 1000,
  "resultMode": "emailsOnly",
  "maxPagesPerWebsite": 3,
  "concurrency": 100,
  "requestTimeoutSecs": 5,
  "extractPhones": true,
  "extractSocials": true,
  "includePersonalData": true,
  "sameDomainOnly": true
}
```

# Actor output Schema

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

Website contact results saved to the default dataset.

## `summary` (type: `string`):

Run-level diagnostics, including processed websites, saved results, filters, and PPE budget details.

# 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": [
        "centralrestaurante.com",
        "alchemist.dk",
        "caitlinmcweeney.com"
    ],
    "maxResults": 1000,
    "resultMode": "emailsOnly",
    "maxPagesPerWebsite": 3,
    "concurrency": 100,
    "requestTimeoutSecs": 5,
    "extractPhones": true,
    "extractSocials": true,
    "includePersonalData": true,
    "sameDomainOnly": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("x_guru/website-email-phone-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": [
        "centralrestaurante.com",
        "alchemist.dk",
        "caitlinmcweeney.com",
    ],
    "maxResults": 1000,
    "resultMode": "emailsOnly",
    "maxPagesPerWebsite": 3,
    "concurrency": 100,
    "requestTimeoutSecs": 5,
    "extractPhones": True,
    "extractSocials": True,
    "includePersonalData": True,
    "sameDomainOnly": True,
}

# Run the Actor and wait for it to finish
run = client.actor("x_guru/website-email-phone-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": [
    "centralrestaurante.com",
    "alchemist.dk",
    "caitlinmcweeney.com"
  ],
  "maxResults": 1000,
  "resultMode": "emailsOnly",
  "maxPagesPerWebsite": 3,
  "concurrency": 100,
  "requestTimeoutSecs": 5,
  "extractPhones": true,
  "extractSocials": true,
  "includePersonalData": true,
  "sameDomainOnly": true
}' |
apify call x_guru/website-email-phone-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Email Scraper & Phone Finder ✅ $2/1k",
        "description": "From $2.00 / 1,000 saved results. Website email scraper and domain email finder for lead generation: public business emails, phones, social profiles, source URLs, and contact-page diagnostics from domains.",
        "version": "0.1",
        "x-build-id": "ZyfPn73fQVpy9A6gF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/x_guru~website-email-phone-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-x_guru-website-email-phone-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/x_guru~website-email-phone-finder/runs": {
            "post": {
                "operationId": "runs-sync-x_guru-website-email-phone-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/x_guru~website-email-phone-finder/run-sync": {
            "post": {
                "operationId": "run-sync-x_guru-website-email-phone-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": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "🌐 Domains or website URLs",
                        "type": "array",
                        "description": "Domains or full website URLs to scan. You can paste domains such as example.com or URLs such as https://example.com/contact.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "centralrestaurante.com",
                            "alchemist.dk",
                            "caitlinmcweeney.com"
                        ]
                    },
                    "maxResults": {
                        "title": "Maximum saved results",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Maximum number of saved website contact results. In Emails only mode, websites without emails are scanned but not saved.",
                        "default": 1000
                    },
                    "resultMode": {
                        "title": "Result mode",
                        "enum": [
                            "emailsOnly",
                            "contactsOnly",
                            "allWebsites"
                        ],
                        "type": "string",
                        "description": "Choose what should be saved to the dataset.",
                        "default": "emailsOnly"
                    },
                    "maxPagesPerWebsite": {
                        "title": "Pages to check per website",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "How many pages to fetch from each website. The actor starts with the homepage or supplied URL, then follows likely contact/about/legal/team pages.",
                        "default": 3
                    },
                    "concurrency": {
                        "title": "Parallel websites",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many websites to scan in parallel. Increase for large lists; decrease if many websites throttle requests.",
                        "default": 100
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 2,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Per-page timeout. Short timeouts keep large batches moving quickly.",
                        "default": 5
                    },
                    "extractPhones": {
                        "title": "Extract phones",
                        "type": "boolean",
                        "description": "Extract public phone numbers from visible page text and tel: links.",
                        "default": true
                    },
                    "extractSocials": {
                        "title": "Extract social profiles",
                        "type": "boolean",
                        "description": "Extract public Facebook, Instagram, LinkedIn, X/Twitter, YouTube, and TikTok profile links.",
                        "default": true
                    },
                    "includePersonalData": {
                        "title": "Personal data",
                        "type": "boolean",
                        "description": "Enable person-like emails and personal LinkedIn profile URLs found on public websites. Disable to keep mostly generic company inboxes.",
                        "default": true
                    },
                    "sameDomainOnly": {
                        "title": "Same-domain crawl only",
                        "type": "boolean",
                        "description": "Only follow contact/about links on the same root domain. Social profile links are still extracted.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
