# Extract Emails Contacts And Socials From Any Website (`scrapers-hub/extract-emails-contacts-and-socials-from-any-website`) Actor

📧🔎 Extract Emails Contacts And Socials From Any Website—quickly pull verified email addresses, contacts & social profiles from any site. 🚀 Perfect for B2B leads, outreach, sales & marketing research. ⚡ Fast, accurate & easy to use.

- **URL**: https://apify.com/scrapers-hub/extract-emails-contacts-and-socials-from-any-website.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (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 $2.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

### Extract Emails Contacts And Socials From Any Website 📬

**Extract Emails Contacts And Socials From Any Website** automatically scrapes **emails, phone numbers, and social media links** from websites to help you build cleaner outreach lists faster. If you’re trying to **extract email addresses from website** pages, run **bulk email extraction from websites**, or **scrape contact information from websites** for lead generation, this actor streamlines the workflow—so you can save hours of manual research.

Whether you’re a marketer, recruiter, data analyst, or researcher, this **email scraper tool** is built for finding contact details at scale—helping you generate leads with **extract emails and socials for outreach**.

---

### Why choose Extract Emails Contacts And Socials From Any Website?

| Feature | Benefit |
|---|---|
| ✅ **All-in-one extraction** | Extract **emails, phone numbers, and social media links** from the same set of website sources |
| ✅ **Built-in proxy support** | Improves reliability when scraping public web data at scale |
| ✅ **Resilient scraping flow** | Includes retries and fallbacks for better success across varying site behavior |
| ✅ **Structured dataset output** | Saves results into a consistent JSON schema for easy downstream processing |
| ✅ **Domain and URL flexibility** | Accepts **website URLs or domains**, letting you start from high-level targets |
| ✅ **Batch-friendly automation** | Helps you collect website contact info scraping outputs across multiple domains in one run |

---

### Key features

- 🔍 **Extract email addresses from website pages**: Collects email contacts found during the crawl and includes metadata for each email.
- 📞 **Collect website emails and phone numbers**: When enabled, also extracts phone numbers alongside email contacts.
- 🌐 **Extract social media profile links**: Finds social media links (deduplicated) and returns them with platform and source context.
- 🧾 **Structured output for analytics**: Produces a dataset table with `domain`, `homepage_url`, `emails`, `phone_numbers`, and `social_media`.
- 🛡️ **Proxy-enabled reliability**: Supports proxy configuration to reduce blocks and improve success rates on real websites.
- 💾 **Export-ready results**: Each domain’s result is pushed into the Apify dataset immediately, so you can export to JSON/CSV workflows.
- 🔄 **Consistency across batches**: Normalizes start inputs into domains and applies the same extraction switches (`extractPhoneNumbers`, `extractSocialMedia`) across all targets.
- 🤖 **Automation-first workflow**: Designed for lead generation email scraping and ongoing enrichment pipelines.

---

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "startUrls": [
    { "url": "https://example.com" },
    { "url": "example.org" }
  ],
  "extractPhoneNumbers": true,
  "extractSocialMedia": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `startUrls` | ✅ | A list of website URLs or domains to scrape (each item contains a `url`). |
| `extractPhoneNumbers` | ❌ | When `true`, the actor extracts phone numbers from pages along with emails. |
| `extractSocialMedia` | ❌ | When `true`, the actor extracts social media profile links (Facebook, Twitter, LinkedIn, Instagram, etc.). |
| `proxyConfiguration` | ❌ | Proxy and browser configuration. Residential proxies are recommended for better success rates. |

##### `proxyConfiguration` object fields

| Field | Required | Description |
|---|---:|---|
| `proxy support` | ❌ | If set, enables Apify Proxy usage for the run (recommended as a starting point for reliable scraping). |

***

### Output

After execution, the actor saves scraped contact data to the **default dataset** (dataset title: **Website Contact Data**) in a JSON format—one record per scraped domain.

Example output record:

```json
{
  "domain": "example.com",
  "homepage_url": "https://example.com",
  "emails": [
    {
      "email": "contact@example.com",
      "confidence_score": 72.5,
      "source_url": "https://example.com/contact",
      "source_type": "contact_page",
      "validation_status": "unknown"
    }
  ],
  "phone_numbers": [
    {
      "phone": "+1 555 123 4567",
      "formatted": "+15551234567",
      "source_url": "https://example.com/contact"
    }
  ],
  "social_media": [
    {
      "platform": "linkedin",
      "url": "https://www.linkedin.com/company/example",
      "source_url": "https://example.com/about"
    }
  ]
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `domain` | string | The domain being scraped. |
| `homepage_url` | string | Homepage URL for the domain (formatted as `https://{domain}`). |
| `emails` | array | List of extracted email objects (includes confidence and source metadata). |
| `emails[].email` | string | The extracted email address. |
| `emails[].confidence_score` | number | Confidence score for the extracted email. |
| `emails[].source_url` | string | URL where the email was found. |
| `emails[].source_type` | string | The detected source type (for example: `contact_page`, `footer`, `body`, `header`). |
| `emails[].validation_status` | string | Email validation status value (as returned by the job results). |
| `phone_numbers` | array | List of extracted phone number objects (empty unless enabled and found). |
| `phone_numbers[].phone` | string | Extracted phone number. |
| `phone_numbers[].formatted` | string | Formatted phone number (E.164-style formatting when available). |
| `phone_numbers[].source_url` | string | URL where the phone number was found. |
| `social_media` | array | List of extracted social media objects (deduplicated by normalized URL). |
| `social_media[].platform` | string | Social platform label (e.g., `facebook`, `twitter`, `linkedin`, `instagram`, etc.). |
| `social_media[].url` | string | Original social media link. |
| `social_media[].source_url` | string | URL where the social link was found. |

You can export the dataset from Apify as needed (for example, JSON or CSV) and feed it directly into your **scrape contact information from websites** workflows.

***

### How to use Extract Emails Contacts And Socials From Any Website (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and open the **Actors** tab.

2. **Open the actor page**\
   Find **Extract Emails Contacts And Socials From Any Website** and open its actor details.

3. **Add your start targets**\
   In the **INPUT** panel, fill `startUrls` with website URLs or domains (e.g. `https://example.com` or `example.org`).

4. **Choose what to extract**\
   Toggle `extractPhoneNumbers` and `extractSocialMedia` depending on whether you also want phones and social links along with emails.

5. **Set proxy configuration (recommended)**\
   Use `proxyConfiguration` and enable the provided proxy option (the input supports `proxy support`) to help improve scraping success on real-world sites.

6. **Run the actor**\
   Click **Run** to start. While it runs, watch the logs for per-domain progress and any domain-level errors.

7. **Review and export results**\
   After completion, open the **OUTPUT** tab and view the **Website Contact Data** dataset. Export the results to JSON/CSV for analysis, CRM import, or lead enrichment.

No coding required—get accurate results in minutes with this **email scraper tool** built for **website contact info scraping** at scale.

***

### Advanced features & SEO optimization

- 🚀 **Engineered for bulk lead enrichment**: Great for **bulk email extraction from websites** and **lead generation email scraping** when you provide multiple domains at once.
- 🧭 **Domain-first workflow**: You can give URLs or bare domains—then the actor converts inputs into domains and builds `homepage_url` automatically.
- 📊 **High-signal output structure**: Emails include `confidence_score`, `source_url`, `source_type`, and `validation_status`, so your downstream **extract emails and socials for outreach** pipeline has context.
- 🔄 **Deduplicated social links**: Social media entries are deduplicated using a normalized URL, helping keep your dataset clean.
- 🧱 **Reliability focus**: Proxy support plus a resilient scraping flow helps achieve better success rates on varied public web pages.

***

### Best use cases

- 📈 **B2B lead generation teams**: Build outreach lists by collecting website contact details and socials in a single run.
- 🎯 **Marketing ops and growth**: Enrich campaign targets by extracting emails and phone numbers from company websites.
- 🧑‍💼 **Recruiters & talent sourcers**: Find contact emails for HR or leadership pages when researching organizations.
- 🔎 **Data analysts**: Combine `emails`, `phone_numbers`, and `social_media` per domain to measure contact coverage across industries.
- 🧾 **Sales teams**: Speed up prospect research with **find contact emails on any website** outputs packaged per domain.
- 💬 **Community and partnerships researchers**: Collect social profile links (e.g., LinkedIn or Instagram) alongside direct contact emails.
- 🛠️ **Developer workflows**: Feed clean JSON records into pipelines that support **data mining contacts and socials** and automated enrichment.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `startUrls` as an array of objects with a `url` field
  - ✅ Accepts both full website URLs and plain domains
- **Proxy Support**
  - ✅ Proxy configuration supported via `proxyConfiguration` (including `proxy support`)
- **Retry Mechanism**
  - ✅ Includes retries and fallbacks for resilience (exact internal behavior not exposed)
- **Dataset Structure**
  - ✅ One output record per domain with: `domain`, `homepage_url`, `emails`, `phone_numbers`, `social_media`
- **Rate Limits & Performance**
  - ⚠️ Scraping performance varies by site accessibility and network conditions; limit behavior is controlled internally (not exposed as an input)
- **Limitations**
  - ⚠️ Only retrieves contact details available on **publicly accessible sources**
  - ⚠️ Results depend on what each website exposes (some sites may not publish phones or social links)

***

### FAQ

#### ✅ What does Extract Emails Contacts And Socials From Any Website extract from a site?

It extracts **email addresses**, and—depending on your switches—also extracts **phone numbers** and **social media links** from pages associated with the provided domains.

#### ✅ Do I need full URLs, or can I input domains?

You can provide both. The actor accepts entries in `startUrls` as website URLs (like `https://example.com`) or plain domains (like `example.org`).

#### ✅ Where do the results go after the run?

Results are saved into the actor’s default Apify dataset titled **Website Contact Data**, with one JSON record per scraped domain.

#### ❌ Does it scrape private or authenticated pages?

No. The actor is intended for **publicly accessible sources** only. It does not access private profiles, password-protected content, or authenticated-only data.

#### 💻 Can I use this actor in an API or automation pipeline?

Yes. As an Apify actor, you can run it via Apify’s platform workflow and then consume the dataset output in your automation—ideal for **extract contact details from any website** pipelines.

#### 🔁 Is social media extraction deduplicated?

Yes. Social links in `social_media` are deduplicated by a normalized URL, helping keep your output stable for downstream systems.

#### ⚖️ Is it legal to use this for outreach and lead generation?

Using extracted data for outreach is your responsibility. Make sure you comply with relevant privacy laws (for example GDPR/CCPA), anti-spam regulations, and each website’s terms of service.

#### 🧹 How can I request data removal?

For data removal requests, contact <dataforleads@gmail.com>.

***

### Support & feature requests

Want to improve **Extract Emails Contacts And Socials From Any Website** or suggest enhancements for faster **bulk email extraction from websites**?

- 💡 **Feature Requests**: For example, add more export options (CSV), support custom email parsing rules, or expand social platform coverage in the `social_media` output.
- 📧 **Contact**: Email <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for this **web scraping for email and social profiles** workflow.

***

### Closing CTA / Final thoughts

*If you need the most streamlined, SEO-optimized way to **Extract Emails Contacts And Socials From Any Website**, this actor is built to help you scale contact discovery across many domains fast.*\
Collect emails, phones, and socials with clean structured output—so you can turn public web data into actionable outreach lists.

***

### Disclaimer

**This tool only accesses publicly accessible sources.** It does not access private profiles, password-protected content, or authenticated data.

You are responsible for complying with applicable laws and regulations (including GDPR/CCPA where relevant), as well as each website’s terms of service and any applicable anti-spam rules. For data removal requests, contact <dataforleads@gmail.com>.

Use **Extract Emails Contacts And Socials From Any Website** responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

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

List of website URLs or domains to scrape (e.g., https://example.com or example.com).

## `extractPhoneNumbers` (type: `boolean`):

Extract phone numbers from pages along with emails.

## `extractSocialMedia` (type: `boolean`):

Extract social media profile links (Facebook, Twitter, LinkedIn, Instagram, etc.).

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

Select proxy settings. Residential proxies recommended for better success rates.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://apify.com"
    }
  ],
  "extractPhoneNumbers": true,
  "extractSocialMedia": true,
  "proxyConfiguration": {
    "useApifyProxy": 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"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/extract-emails-contacts-and-socials-from-any-website").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" }],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/extract-emails-contacts-and-socials-from-any-website").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"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapers-hub/extract-emails-contacts-and-socials-from-any-website --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapers-hub/extract-emails-contacts-and-socials-from-any-website",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Extract Emails Contacts And Socials From Any Website",
        "description": "📧🔎 Extract Emails Contacts And Socials From Any Website—quickly pull verified email addresses, contacts & social profiles from any site. 🚀 Perfect for B2B leads, outreach, sales & marketing research. ⚡ Fast, accurate & easy to use.",
        "version": "1.0",
        "x-build-id": "VRIMjkSsm07zfrSro"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~extract-emails-contacts-and-socials-from-any-website/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-extract-emails-contacts-and-socials-from-any-website",
                "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/scrapers-hub~extract-emails-contacts-and-socials-from-any-website/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-extract-emails-contacts-and-socials-from-any-website",
                "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/scrapers-hub~extract-emails-contacts-and-socials-from-any-website/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-extract-emails-contacts-and-socials-from-any-website",
                "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": "Website URLs or Domains",
                        "type": "array",
                        "description": "List of website URLs or domains to scrape (e.g., https://example.com or example.com).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "extractPhoneNumbers": {
                        "title": "Extract Phone Numbers",
                        "type": "boolean",
                        "description": "Extract phone numbers from pages along with emails.",
                        "default": true
                    },
                    "extractSocialMedia": {
                        "title": "Extract Social Media Links",
                        "type": "boolean",
                        "description": "Extract social media profile links (Facebook, Twitter, LinkedIn, Instagram, etc.).",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Select proxy settings. Residential proxies recommended for better success rates."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
