# Email ✉️ & Phone 📞 Extractor (`scrapium/email-and-phone-extractor`) Actor

📧📞 Email & Phone Extractor Scraper pulls contact details from websites and lists—emails, phone numbers, and sources for verification. Perfect for lead gen, B2B outreach, and CRM enrichment. Fast, accurate, and easy to use. 🚀

- **URL**: https://apify.com/scrapium/email-and-phone-extractor.md
- **Developed by:** [Scrapium](https://apify.com/scrapium) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 & Phone Extractor 📞 — Contact Details Scraper

**Extract emails, phone numbers, and social media profiles from any website.**
Point this actor at one website or thousands — it crawls each one, follows the
links you allow, and pulls out every public contact detail it can find. Built
for **lead generation**, **sales prospecting**, and **data enrichment**.

---

### 💡 Why Choose This Actor?

- 🧠 **Smart proxy escalation** — starts with **no proxy** for speed, and only
  escalates to a **datacenter** and then **residential** proxy *if* a website
  blocks it. You pay for heavy proxies only when you actually need them.
- 🎭 **JavaScript fallback** — pages that need a browser are automatically
  re-rendered with a real Chromium browser, so dynamic contact details are
  never missed.
- ☎️ **Real phone validation** — numbers are verified against actual numbering
  plans (libphonenumber), so you get clean `+E.164` numbers instead of random
  digit soup.
- 📡 **Live results** — every page is saved to the dataset the moment it is
  scraped, and the run log streams real-time progress.
- 🌐 **Social profiles too** — LinkedIn, X/Twitter, Instagram, Facebook & YouTube.
- 📥 **Bulk input** — paste a list, upload a file, or link a Google Sheet.

---

### ✨ Key Features

| Feature | Description |
|---------|-------------|
| 📧 Email extraction | From visible text and `mailto:` links |
| 📞 Phone extraction | `tel:` links + validated free-text numbers (E.164) |
| 🌐 Social profiles | LinkedIn, X/Twitter, Instagram, Facebook, YouTube |
| 🪜 Deep crawling | Follow links to a configurable depth |
| 🎯 Link filtering | Regex patterns + same-domain restriction |
| 🖼️ IFRAME probing | Reads contact details embedded in child frames |
| 🛡️ Auto proxy fallback | No proxy → datacenter → residential, automatically |
| 🎭 JS rendering | Real-browser fallback for dynamic websites |

---

### 📥 Input

| Field | Type | Description |
|-------|------|-------------|
| `startUrls` ✅ | array | Website URLs to crawl. Bulk paste / file / Google Sheet supported. |
| `maxRequests` | integer | Total maximum pages to load (default `20`). |
| `maxDepth` | integer | How deep to follow links (default `2`). |
| `maxRequestsPerStartUrl` | integer | Optional per-website page limit. |
| `maxConcurrency` | integer | Pages fetched in parallel (default `5`). |
| `requestDelay` | number | Polite delay between requests, seconds (default `1.0`). |
| `sameDomain` | boolean | Only follow links on the same domain (default `true`). |
| `pseudoUrls` | array | Regex link filters (default `[".*"]`). |
| `considerChildFrames` | boolean | Probe IFRAMEs for contacts (default `true`). |
| `onlyEmails` | boolean | Extract only emails (default `false`). |
| `onlyOneEmailPerDomain` | boolean | Stop a site after the first email (default `false`). |
| `defaultPhoneRegion` | string | Region for local-format phone numbers (default auto). |
| `usePlaywrightFallback` | boolean | Re-render JS-heavy pages (default `true`). |
| `proxyConfiguration` | object | Proxy settings — **disabled by default**. |

#### Example input

```json
{
  "startUrls": [{ "url": "https://apify.com/contact" }],
  "maxRequests": 20,
  "maxDepth": 2,
  "sameDomain": true,
  "onlyEmails": false,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

***

### 📤 Output

Each crawled page becomes one dataset record:

```json
{
  "depth": 0,
  "referrerUrl": null,
  "url": "https://apify.com/contact",
  "domain": "apify.com",
  "image": "https://apify.com/favicon.ico",
  "emails": ["hello@apify.com"],
  "phones": [],
  "phonesUncertain": [],
  "linkedIns": ["https://www.linkedin.com/company/apify/"],
  "twitters": ["https://x.com/apify"],
  "instagrams": [],
  "facebooks": [],
  "youtubes": ["https://www.youtube.com/apify"]
}
```

| Field | Description |
|-------|-------------|
| `depth` | Link distance from the start URL (`0` = start page). |
| `referrerUrl` | The page this URL was discovered on. |
| `url` / `domain` | The scraped page and its domain. |
| `image` | The website favicon. |
| `emails` | Email addresses found. |
| `phones` | Validated phone numbers in `+E.164` format. |
| `phonesUncertain` | Plausible numbers that did not fully validate. |
| `linkedIns` / `twitters` / `instagrams` / `facebooks` / `youtubes` | Social profile URLs. |

The **Output** tab shows the data split into handy views: 🗂️ Contact Overview,
📧 Emails, 📞 Phone Numbers, and 🌐 Social Profiles.

***

### 🚀 How to Use (Apify Console)

1. Log in at [console.apify.com](https://console.apify.com) → **Actors**.
2. Open **Email & Phone Extractor**.
3. Paste your website URLs into **🔗 Website URLs**.
4. Adjust crawl depth, page limit, and filters if needed.
5. Click **Start**.
6. Watch the **run log** stream live progress.
7. Open the **Output** tab when the run finishes.
8. Export to **JSON / CSV / Excel**.

***

### 🤖 Use via API

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
       "startUrls": [{ "url": "https://apify.com/contact" }],
       "maxRequests": 20,
       "maxDepth": 2
     }'
```

***

### 🛡️ How Proxy Fallback Works

1. **Direct first** — requests go out with no proxy for maximum speed.
2. **Datacenter** — if a website blocks the request, every following request
   switches to a datacenter proxy.
3. **Residential** — if blocking continues, the run upgrades to residential
   proxies and retries up to 3 times per page.
4. The escalation is **sticky** — once upgraded, it stays upgraded.

Every proxy switch is logged clearly so you always know what happened.

***

### 🎯 Best Use Cases

- 🧲 Lead generation and sales prospecting lists
- 🗂️ CRM data enrichment
- 🔎 Market & competitor research
- 🏢 Building agency / supplier contact directories

***

### 💳 Pricing

This actor uses the **pay-per-event** model and bills a single event:

| Event | What it bills for |
|-------|-------------------|
| `apify-default-dataset-item` | One scraped page saved to the dataset |

You are billed per page of results. Results are saved live, page by page,
so if a run reaches your charge limit the platform stops it automatically
and everything collected so far is kept.

***

### ❓ Frequently Asked Questions

**Does it find every email on a website?**
It finds every publicly visible email in page text, `mailto:` links, and
IFRAMEs, up to the crawl depth and page limit you set. Increase `maxDepth` and
`maxRequests` to dig deeper.

**Why are some numbers in `phonesUncertain`?**
Those are plausible-looking numbers that did not fully pass numbering-plan
validation. Set `defaultPhoneRegion` to the country of the websites you scrape
to validate more local-format numbers.

**A website blocked the actor — what now?**
Nothing to do — the actor automatically escalates to datacenter and then
residential proxies. You can also pre-select a proxy in the input.

**Can I scrape thousands of websites at once?**
Yes. Paste them all, upload a file, or link a Google Sheet in the
**🔗 Website URLs** field.

***

### ⚖️ Legal & Fair Use

This actor collects only **publicly available** information. You are
responsible for using the data in compliance with applicable laws (GDPR,
CCPA, anti-spam regulations) and the target websites' terms of service.

***

### 🆘 Support & Feedback

Found a bug or have a feature request? Open an issue on the actor's **Issues**
tab in the Apify Console — feedback is always welcome.

# Actor input Schema

## `startUrls` (type: `array`):

One or more website URLs to crawl for contact details (e.g. https://apify.com/contact). Bulk input is supported — paste a list, use Bulk edit, or load a text file / Google Sheet.

## `maxRequests` (type: `integer`):

The hard cap on how many pages the crawler will load in total across all websites.

## `sameDomain` (type: `boolean`):

When enabled, the crawler only follows links that stay on the start URL's domain.

## `onlyEmails` (type: `boolean`):

When enabled, only email addresses are extracted — phone numbers and social profiles are skipped.

## `onlyOneEmailPerDomain` (type: `boolean`):

Stop crawling a website as soon as the first email address is found on it.

## `maxDepth` (type: `integer`):

How deep to follow links from each start URL. 0 = only the start pages, 1 = start pages + their links, and so on.

## `maxRequestsPerStartUrl` (type: `integer`):

Optional limit on how many pages may be loaded for each individual start URL. Leave empty for no per-URL limit.

## `pseudoUrls` (type: `array`):

Only links matching one of these regular expressions are followed. The default `.*` follows every link.

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

How many pages to fetch in parallel. Higher = faster, but more likely to be rate-limited.

## `requestDelay` (type: `number`):

A polite pause added after each page. Random jitter is added automatically to look more human.

## `defaultPhoneRegion` (type: `string`):

Region used to validate phone numbers written without a +country code. Leave on auto-detect to infer it from each website.

## `usePlaywrightFallback` (type: `boolean`):

If a page looks like it needs JavaScript, re-render it in a real browser so dynamic contact details are not missed.

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

By default the crawler runs WITHOUT a proxy. If a website blocks it, the Actor automatically escalates to a datacenter proxy and then to residential proxies. You can also pre-select a proxy here.

## `considerChildFrames` (type: `boolean`):

Also extract contact details embedded inside child frames (IFRAMEs) on the page.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://apify.com/contact"
    }
  ],
  "maxRequests": 20,
  "sameDomain": true,
  "onlyEmails": false,
  "onlyOneEmailPerDomain": false,
  "maxDepth": 2,
  "pseudoUrls": [
    ".*"
  ],
  "maxConcurrency": 5,
  "requestDelay": 1,
  "defaultPhoneRegion": "",
  "usePlaywrightFallback": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "considerChildFrames": true
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://apify.com/contact"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapium/email-and-phone-extractor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://apify.com/contact" }],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapium/email-and-phone-extractor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://apify.com/contact"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapium/email-and-phone-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Email ✉️ & Phone 📞 Extractor",
        "description": "📧📞 Email & Phone Extractor Scraper pulls contact details from websites and lists—emails, phone numbers, and sources for verification. Perfect for lead gen, B2B outreach, and CRM enrichment. Fast, accurate, and easy to use. 🚀",
        "version": "0.1",
        "x-build-id": "9agB0LOsWv0y4i7F4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapium~email-and-phone-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapium-email-and-phone-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapium~email-and-phone-extractor/runs": {
            "post": {
                "operationId": "runs-sync-scrapium-email-and-phone-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapium~email-and-phone-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-scrapium-email-and-phone-extractor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔗 Start URLs",
                        "type": "array",
                        "description": "One or more website URLs to crawl for contact details (e.g. https://apify.com/contact). Bulk input is supported — paste a list, use Bulk edit, or load a text file / Google Sheet.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxRequests": {
                        "title": "📄 Total maximum pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "The hard cap on how many pages the crawler will load in total across all websites.",
                        "default": 20
                    },
                    "sameDomain": {
                        "title": "🏠 Stay within domain",
                        "type": "boolean",
                        "description": "When enabled, the crawler only follows links that stay on the start URL's domain.",
                        "default": true
                    },
                    "onlyEmails": {
                        "title": "📧 Only emails",
                        "type": "boolean",
                        "description": "When enabled, only email addresses are extracted — phone numbers and social profiles are skipped.",
                        "default": false
                    },
                    "onlyOneEmailPerDomain": {
                        "title": "1️⃣ Only one email per website",
                        "type": "boolean",
                        "description": "Stop crawling a website as soon as the first email address is found on it.",
                        "default": false
                    },
                    "maxDepth": {
                        "title": "🪜 Maximum link depth",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How deep to follow links from each start URL. 0 = only the start pages, 1 = start pages + their links, and so on.",
                        "default": 2
                    },
                    "maxRequestsPerStartUrl": {
                        "title": "🔢 Maximum links per start URL",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional limit on how many pages may be loaded for each individual start URL. Leave empty for no per-URL limit."
                    },
                    "pseudoUrls": {
                        "title": "🧭 Links filter (regex patterns)",
                        "type": "array",
                        "description": "Only links matching one of these regular expressions are followed. The default `.*` follows every link.",
                        "default": [
                            ".*"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxConcurrency": {
                        "title": "⚡ Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many pages to fetch in parallel. Higher = faster, but more likely to be rate-limited.",
                        "default": 5
                    },
                    "requestDelay": {
                        "title": "⏳ Delay between requests (seconds)",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "number",
                        "description": "A polite pause added after each page. Random jitter is added automatically to look more human.",
                        "default": 1
                    },
                    "defaultPhoneRegion": {
                        "title": "🌍 Default phone region",
                        "enum": [
                            "",
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "IN",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "BR",
                            "MX",
                            "JP",
                            "SG",
                            "AE",
                            "ZA",
                            "SE",
                            "CH"
                        ],
                        "type": "string",
                        "description": "Region used to validate phone numbers written without a +country code. Leave on auto-detect to infer it from each website.",
                        "default": ""
                    },
                    "usePlaywrightFallback": {
                        "title": "🎭 JavaScript rendering fallback",
                        "type": "boolean",
                        "description": "If a page looks like it needs JavaScript, re-render it in a real browser so dynamic contact details are not missed.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy",
                        "type": "object",
                        "description": "By default the crawler runs WITHOUT a proxy. If a website blocks it, the Actor automatically escalates to a datacenter proxy and then to residential proxies. You can also pre-select a proxy here.",
                        "default": {
                            "useApifyProxy": false
                        }
                    },
                    "considerChildFrames": {
                        "title": "🖼️ Probe frames",
                        "type": "boolean",
                        "description": "Also extract contact details embedded inside child frames (IFRAMEs) on the page.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```