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

🌐 Extract emails, contacts & social profiles from any website with our powerful scraper. Get verified leads fast—perfect for B2B outreach, sales, prospecting & market research. 🚀 Effortless data collection, higher response rates.

- **URL**: https://apify.com/scraperoka/extract-emails-contacts-and-socials-from-any-website.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (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 🎯

Manually visiting dozens of pages to collect emails and contact details wastes hours you don’t have. **Extract Emails Contacts And Socials From Any Website** automatically scrapes emails, phone numbers, and social media profile links from websites so you can build lead lists fast. This Extract Emails Contacts And Socials From Any Website email and contact scraper is ideal for marketers, recruiters, and growth teams who want to extract email addresses and phone numbers at scale—often thousands of contacts in a single run.

---

### What You Get: Sample Output

Here's a sample record from a single run:

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

| Field | Type | What It Tells You |
|---|---|---|
| `domain` | string | The domain you provided (used as the primary identifier for the scraped results) |
| `homepage_url` | string | A direct homepage link for quick human verification |
| `emails` | array | A list of extracted email contacts (including confidence and where they were found) |
| `emails[].email` | string | The actual extracted email address you can use for outreach workflows |
| `emails[].confidence_score` | number | A confidence signal for prioritizing the best addresses first |
| `emails[].source_url` | string | The page where the email was discovered (great for validation) |
| `emails[].source_type` | string | The page/context type (for example, contact page vs footer) |
| `emails[].validation_status` | string | Validation status label returned by the actor |
| `phone_numbers` | array | Extracted phone numbers found alongside emails (when enabled) |
| `phone_numbers[].phone` | string | Raw phone number as extracted from the page |
| `phone_numbers[].formatted` | string | Normalized formatted phone value when available |
| `phone_numbers[].source_url` | string | The page where the phone number was discovered |
| `social_media` | array | Deduplicated social profile links found on the site (when enabled) |
| `social_media[].platform` | string | Social platform name (e.g., LinkedIn, Facebook, Instagram, etc.) |
| `social_media[].url` | string | The profile link you can open or store directly |
| `social_media[].source_url` | string | The page where the social link was discovered |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

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

There are a lot of ways to pull data from the web — here’s what sets Extract Emails Contacts And Socials From Any Website apart.

#### Email, phone, and socials in one pass

This Extract Emails Contacts And Socials From Any Website email and contact scraper focuses on collecting the core outreach fields: emails, phone numbers (optional), and social media profile links (optional). You can toggle phone and social extraction depending on how you plan to use the data.

#### Flexible input: URLs or domains

You can provide `startUrls` as a mix of full URLs (like `https://example.com`) or domains (like `example.com`). The actor extracts the domain(s) and returns results grouped by domain so your lead lists stay clean and organized.

#### Deduplicated social media output

Social links are deduplicated by a normalized `clean_url`, so you avoid repeated entries when the same profile appears multiple times across the website. This makes the “collect email contacts and socials” workflow much easier to manage in downstream tools.

#### Built-in resilience and structured results

The actor pushes structured results to the Apify dataset as each domain completes, so you get partial output even if some domains fail. Output is consistent and integration-ready for CRM imports, enrichment workflows, and analysis.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

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

| Parameter | Required | What It Does |
|---|---|---|
| `startUrls` | ✅ | The website URLs or domains you want to scrape for email contacts and socials |
| `extractPhoneNumbers` | ⬜ | When `true`, the actor also extracts phone numbers from pages along with emails |
| `extractSocialMedia` | ⬜ | When `true`, the actor extracts social media profile links (Facebook, Twitter, LinkedIn, Instagram, etc.) |
| `proxyConfiguration` | ⬜ | Choose proxy settings to improve scraping success rates |
| ↳ `proxy support` | ⬜ | Set to `true` to enable Apify Proxy for the run |

***

### Core Capabilities

#### Scrapes emails and contact details from websites

Extract Emails Contacts And Socials From Any Website collects email contacts and returns them with metadata such as `confidence_score`, `source_url`, `source_type`, and `validation_status`. This gives you more context than a simple “email-only” extractor.

#### Optional phone extraction for richer outreach

With `extractPhoneNumbers: true`, the actor also returns `phone_numbers` including `formatted` and the `source_url` where each phone number was found. This helps when you run mixed outreach (email + call) campaigns.

#### Optional social extraction to build complete lead profiles

With `extractSocialMedia: true`, you get a deduplicated `social_media` list with `platform`, `url`, and `source_url`. This supports workflows like collect email contacts and socials for faster lead research.

#### Resilient runs with clear failure handling

If a domain errors, the actor still pushes a result object for that domain with empty arrays for `emails`, `phone_numbers`, and `social_media`. That way, your pipeline can keep moving and you can track which domains returned no data.

#### Works well for bulk lead collection

You can submit multiple websites in `startUrls`, and the actor processes each domain and pushes results to your dataset as it goes. This makes the actor a practical website lead extraction tool for B2B lead generation email scraper use cases.

***

### Who Gets the Most Out of This

You’ll get the best results with Extract Emails Contacts And Socials From Any Website when you need structured contact data quickly.

**Sales Development Representatives** — Use this Extract Emails Contacts And Socials From Any Website email and contact scraper to turn a list of target company websites into outreach-ready contact datasets, helping you move from website research to first emails faster.

**Marketers & Growth Teams** — When you need to scrape contact information from websites at scale, this tool helps you collect emails and (optionally) phone numbers and social media profiles so your lead lists include multiple channels.

**Recruiters & Talent Sourcers** — If you’re sourcing roles or agencies and need direct company contact routes, extract emails from any website and pair them with socials to improve your first-step messaging quality.

**Freelance Researchers & Analysts** — Use this actor to deliver consistent, integration-ready datasets for contact and website lead extraction tasks, with source context (`source_url`, `source_type`) to support verification.

**Developers & Automation Specialists** — If you want a reliable data source to pull into your pipeline, the actor’s structured dataset output and export options make it straightforward to integrate into enrichment workflows and dashboards.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Extract Emails Contacts And Socials From Any Website from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find the actor page.
2. **Enter your inputs** — add your websites in `startUrls`, and set `extractPhoneNumbers` and `extractSocialMedia` based on what you need.
3. **Configure proxy settings** — enable the proxy option in `proxyConfiguration` for better reliability on larger batches.
4. **Hit Run and watch the live log** — monitor progress as each domain is processed.
5. **View results in the dataset tab** — each domain produces a structured result with `domain`, `homepage_url`, and extracted contacts.
6. **Export as JSON, CSV, or Excel** — download from the Apify dataset tab in the format your team uses.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Extract Emails Contacts And Socials From Any Website plugs directly into your existing workflow.

Export your scraped results in the formats supported by the Apify dataset tab (JSON, CSV, or Excel). From there, you can import into most CRMs and contact databases.

For programmatic workflows, you can pull results using the Apify API—see the Apify developer docs: https://apify.com/docs/api. You can also automate downstream actions using Apify-compatible tools like Zapier/Make, and connect results to webhooks so alerts or enrichment steps run automatically after completion.

***

### Pricing & Free Trial

Extract Emails Contacts And Socials From Any Website runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You’ll typically test with free platform credits, then scale using Apify’s pay-as-you-go compute model and subscription options based on your usage.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Block resistance | Supports proxy configuration to improve success rates |
| Data collection continuity | Results are pushed to the dataset as domains complete |
| Partial failures | If a domain fails, an empty-result record is still pushed for that domain |
| Output consistency | Email, phone, and social fields keep a stable structure for easy processing |
| Scale within a single run | Designed to handle multiple domains in one execution |

**Limitations:** This actor extracts data from publicly available sources on websites. If a website doesn’t publish email addresses, phone numbers, or social links, those arrays may be empty.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes—Apify offers a free tier so you can run Extract Emails Contacts And Socials From Any Website without a credit card. It’s designed for quick tests with platform credits.

#### Do I need to log in to use this?

No. Extract Emails Contacts And Socials From Any Website is intended for scraping data that’s publicly accessible on the websites you provide.

#### How accurate is the data?

Accuracy depends on what the website publishes. The actor extracts email addresses and contact links it finds, and returns additional metadata like `confidence_score` and `validation_status` for emails.

#### How many results can I get per run?

Your results depend on how many sites you provide and how much contact info those sites contain. The actor processes a limited number of pages per domain per run, returning structured results per domain.

#### How often is the data updated / how fresh is it?

The data freshness depends on when you run the actor. Each run scrapes the current publicly available content from the websites you list, so results reflect that point in time.

#### Is this legal? Does it comply with GDPR / CCPA?

Yes in the sense that it works with **publicly available data**. However, compliance (GDPR/CCPA and any applicable rules) is ultimately your responsibility when storing and using contact information.

#### Can I export results to Google Sheets or Excel?

Yes. You can export from the Apify dataset tab in supported formats like JSON, CSV, or Excel, and then use your preferred workflow to load into Google Sheets or other tools.

#### Can I run this on a schedule automatically?

Yes. You can schedule runs using Apify’s scheduling capabilities so Extract Emails Contacts And Socials From Any Website runs automatically according to your needs.

#### Can I access this via API?

Yes. You can trigger and retrieve results programmatically using the Apify API. For details, see https://apify.com/docs/api.

#### What happens if the actor hits an error?

If scraping a specific domain errors, the actor still pushes a result object for that domain with empty `emails`, `phone_numbers`, and `social_media`. This helps keep your dataset consistent even when individual websites fail.

***

### Need Help or Have a Request?

Got a question about Extract Emails Contacts And Socials From Any Website or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help you get the best results and we actively maintain this actor based on user feedback. If you want ideas like webhook notifications on completion or additional output fields, tell us what your workflow needs.

***

### Disclaimer & Responsible Use

Extract Emails Contacts And Socials From Any Website is the fastest, most reliable way to collect email contacts and socials from websites—start your free run today.

This actor collects **publicly available data** from the websites you provide. It does not access login-gated content, private accounts, or password-protected pages. It’s your responsibility to comply with GDPR, CCPA, platform terms, and any applicable local regulations when using or storing the extracted data. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# 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("scraperoka/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("scraperoka/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 scraperoka/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=scraperoka/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 & social profiles from any website with our powerful scraper. Get verified leads fast—perfect for B2B outreach, sales, prospecting & market research. 🚀 Effortless data collection, higher response rates.",
        "version": "1.0",
        "x-build-id": "c0cYYAKxymBIhDpBX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~extract-emails-contacts-and-socials-from-any-website/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-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/scraperoka~extract-emails-contacts-and-socials-from-any-website/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-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/scraperoka~extract-emails-contacts-and-socials-from-any-website/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
