# Extract Emails Phone Social Media From Website (`scraperoka/extract-emails-phone-social-media-from-website`) Actor

🌐 Extract Emails, Phone & Social Media from Websites with precision. Automatically collect contact details for lead generation, outreach, and B2B research—faster, cleaner, and compliant. 🚀 Ideal for sales & marketing teams.

- **URL**: https://apify.com/scraperoka/extract-emails-phone-social-media-from-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 $0.01 / 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 Phone Social Media From Website 🔍
**Extract Emails Phone Social Media From Website** is a purpose-built Apify actor that scrapes emails, phone numbers, and social media profile links from any website you provide. It helps you solve the common problem of finding real business contact details and social channels scattered across pages—so you can build targeted lead lists faster using email extraction from website, scrape phone numbers from website, and extract social media links from website workflows at scale.

Whether you’re a marketer, recruiter, data analyst, or researcher, this actor makes it easy to collect business contact details from websites and turn public web content into structured data—saving you hours of manual work.

---

### Why choose Extract Emails Phone Social Media From Website?
| Feature | Benefit |
|---|---|
| ✅ **All-in-one contact extraction** | Extract emails, phone numbers, and social media profile links in one run |
| ✅ **Configurable extraction toggles** | Enable or disable phone and social media extraction depending on your needs |
| ✅ **Built-in proxy support** | Scrapes reliably with proxy support for smoother access to public web data |
| ✅ **Resilient scraping workflow** | Includes retries and fallbacks for better results across diverse sites |
| ✅ **Structured dataset output** | Saves consistent fields (domain, homepage, emails, phone numbers, social media) for easy import |
| ✅ **Scales across multiple target URLs** | Process multiple websites in a single execution and store results per domain |

---

### Key features
- 📧 **Accurate email extraction**: Extracts email addresses found across target website pages and returns them with confidence and source metadata  
- 📞 **Phone number extraction (optional)**: When enabled, extracts phone numbers found on pages and includes formatting + source URL  
- 🌐 **Social media link extraction (optional)**: Detects and extracts social media profile links (and deduplicates them in the output)  
- 🛡️ **Proxy support for reliability**: Supports proxy configuration to help avoid blocking during scraping  
- 🔄 **Resilience for real-world sites**: Includes retries and fallbacks for robustness across different site structures  
- 📊 **Complete, structured output**: Produces a consistent dataset you can use for lead generation from website contact info  
- 💾 **Automation-ready results**: Outputs are immediately pushed to the Apify dataset for downstream exporting to JSON/CSV pipelines  

---

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

```json
{
  "targetUrls": [
    { "url": "https://apify.com" }
  ],
  "enablePhoneExtraction": true,
  "enableSocialMediaExtraction": true,
  "proxySettings": {
    "useApifyProxy": true
  }
}
````

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `targetUrls` | Yes | List of target website URLs to scrape for contact information. Provide objects with a `url` field. |
| `enablePhoneExtraction` | No | If set to `true`, the actor also extracts phone numbers found on the pages. Default: `true`. |
| `enableSocialMediaExtraction` | No | If set to `true`, the actor detects and extracts social media profile links (e.g., LinkedIn, Twitter, Facebook). Default: `true`. |
| `proxySettings` | No | Proxy configuration for the actor. Proxy usage is recommended for reliable scraping of public web data. |
| `proxySettings.proxy support` | No | Set to `true` to enable Apify Proxy usage (prefilled as `true`). |

***

### Output

The actor pushes each scraped domain’s results into the Apify dataset as JSON.

```json
{
  "domain": "example.com",
  "homepage_url": "https://example.com",
  "emails": [
    {
      "email": "contact@example.com",
      "confidence_score": 92.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 extracted from your target URL |
| `homepage_url` | string | The homepage URL built as `https://{domain}` |
| `emails` | array | Extracted email objects for the domain |
| `emails[].email` | string | The email address found on the website |
| `emails[].confidence_score` | number | Confidence score associated with the extracted email |
| `emails[].source_url` | string | Page URL where the email was found |
| `emails[].source_type` | string | The source type where the email was extracted from (e.g., `contact_page`, `footer`, etc.) |
| `emails[].validation_status` | string | Validation status for the extracted email |
| `phone_numbers` | array | Extracted phone number objects for the domain |
| `phone_numbers[].phone` | string | The phone value found on the website |
| `phone_numbers[].formatted` | string | Formatted phone value |
| `phone_numbers[].source_url` | string | Page URL where the phone number was found |
| `social_media` | array | Extracted social media profile links (deduplicated in the output) |
| `social_media[].platform` | string | Social platform name (e.g., `linkedin`, `twitter`, etc.) |
| `social_media[].url` | string | The social profile URL as found |
| `social_media[].source_url` | string | Page URL where the social link was detected |
| `error_message` | string | Not present in the normal output object above; if a domain errors, the actor pushes an empty-result object for that domain |

You can export the resulting dataset to JSON or CSV from the Apify Console output tools after the run completes.

***

### How to use Extract Emails Phone Social Media From Website (via Apify Console)

1. **Open Apify Console**\
   Go to [console.apify.com](https://console.apify.com) and sign in.

2. **Find the actor**\
   Search for **Extract Emails Phone Social Media From Website** and open the actor page.

3. **Go to the INPUT panel**\
   In the input form, add your **Target Websites** under `targetUrls` (each item is an object with a `url`).

4. **Choose what to extract**\
   Enable or disable `enablePhoneExtraction` and `enableSocialMediaExtraction` depending on whether you want `scrape phone numbers from website` and `extract social media links from website`.

5. **(Optional) Configure proxy settings**\
   If you expect frequent scraping or you’re hitting access limitations, enable `proxySettings.proxy support` (Apify Proxy) for built-in proxy support.

6. **Run the actor**\
   Click **Run**. Watch the live logs to see which domains are being processed and how many emails/phones/social links were extracted.

7. **Review the dataset**\
   After completion, open the dataset tab. Each row corresponds to one domain with `emails`, `phone_numbers`, and `social_media`.

8. **Export your results**\
   Export to JSON/CSV and feed the data into your CRM, enrichment workflow, or website data extraction emails phones pipeline.

No coding required — get accurate results from publicly available sources in minutes. ✅

***

### Advanced features & SEO optimization

- 🔎 **Engineered for website contact info extraction**: Built to excel at “email extraction from website” and “scrape phone numbers from website” style lead generation from website contact info use cases.
- 🔄 **Deduplicated social results**: Social media profile links are deduplicated by a normalized URL, helping keep your dataset clean when sites repeat the same links in multiple places.
- 🌐 **Flexible extraction controls**: Turn phone and social extraction on/off using `enablePhoneExtraction` and `enableSocialMediaExtraction`, so you only collect what you need.
- 🛡️ **Resilience for diverse sites**: Designed to handle real-world variability across websites using retries and fallbacks for better coverage.

***

### Best use cases

- 📈 **Lead generation from website contact info**: Build outreach lists by collecting emails and phone numbers from company sites and contact pages.
- 🧑‍💼 **Recruitment research**: Pull hiring-team contact details and social profiles to support faster candidate outreach and employer research.
- 🛍️ **Competitive market research**: Compare organizations by extracting contact channels and presence across domains (emails, phones, and social links).
- 🧪 **Data cleansing and enrichment**: Validate and normalize contact data in your pipeline, then enrich profiles using extract emails phone social media from website outputs.
- 🗂️ **Analyst workflows**: Create structured datasets of business contact details and analyze coverage by domain, page context, and source type.
- 💬 **Agency prospecting at scale**: Automate website data extraction emails phones to quickly discover contact methods for multiple client targets.
- 💻 **CRM integration**: Push consistent fields (domain, homepage, emails, phone\_numbers, social\_media) into your system to power follow-up automation.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `targetUrls` as an array of objects containing `url`
  - ✅ `enablePhoneExtraction` boolean (`true`/`false`)
  - ✅ `enableSocialMediaExtraction` boolean (`true`/`false`)
  - ✅ `proxySettings` object with `proxy support` boolean

- **Proxy Support**
  - ✅ Apify Proxy via `proxySettings.proxy support`
  - ❌ Custom proxy types beyond the provided proxy settings are not exposed in the input schema

- **Retry Mechanism**
  - ✅ Includes retries and fallbacks for resilience across websites

- **Dataset Structure**
  - ✅ One dataset row per `domain`, containing `homepage_url`, `emails`, `phone_numbers`, `social_media`

- **Rate Limits & Performance**
  - ✅ Designed for practical throughput across multiple domains
  - ✅ Limits scraping depth to keep runs efficient (the actor uses a fixed `max_pages = 10` per site)

- **Limitations**
  - ❌ Only extracts what’s available in publicly accessible pages (no access to authenticated or private data)
  - ❌ Some sites may contain no email/phone/social links, resulting in empty arrays

***

### FAQ

#### Can I scrape emails, phone numbers, and social media links in one run?

✅ Yes. Extract Emails Phone Social Media From Website can extract email extraction from website results and, when enabled, also scrape phone numbers from website and extract social media links from website in the same execution using `enablePhoneExtraction` and `enableSocialMediaExtraction`.

#### What happens if a website has no contact emails or phone numbers?

✅ If no emails or phones are found, the actor still pushes a result object for that `domain` with `emails` and/or `phone_numbers` as empty arrays.

#### Is proxy support included?

✅ Yes. You can configure `proxySettings` and set `proxySettings.proxy support` to enable built-in proxy support to improve reliability when scraping public web data.

#### Does the actor deduplicate social media links?

✅ Yes. Social media profile entries are deduplicated in the output, helping avoid repeated links across multiple pages on the same domain.

#### How is the output structured for analysis and CRM imports?

✅ The dataset stores consistent JSON objects per domain, with `domain`, `homepage_url`, `emails`, `phone_numbers`, and `social_media`. This makes it easy to map into downstream tools for lead generation from website contact info.

#### Can I run it at scale for many websites?

✅ Yes. The actor processes multiple target URLs in a single run and pushes results to the dataset per domain, which is convenient for bulk lead generation.

#### Do I need to write code to use this actor?

✅ No. You can use it directly via Apify Console by filling the input fields and then exporting the dataset after the run completes.

#### Is this actor legal and compliant to use?

❌ Compliance depends on your use case. The actor works with **publicly accessible sources**, but it is still your responsibility to comply with applicable laws and site policies (including GDPR/CCPA and spam regulations) when using the extracted data.

***

### Support & feature requests

Want to improve Extract Emails Phone Social Media From Website for your workflow? We’d love to hear from you! 🙌

- 💡 **Feature Requests**: Ideas like CSV export customization, additional field enrichment, or custom output formatting for extract emails phone social media from website use cases are welcome.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap and keeps this actor aligned with what marketers, analysts, and researchers need.

***

### *Extract Emails Phone Social Media From Website* — final thoughts

*Extract Emails Phone Social Media From Website* is the most comprehensive, SEO-optimized way to collect business contact details from websites—so you can scale email and contact discovery with clean, structured output. ✅

***

### Disclaimer

**This tool only accesses publicly accessible sources** and does not access private profiles, authenticated data, or password-protected pages. Legal compliance (including GDPR/CCPA), usage permissions, and adherence to each website’s Terms of Service are your responsibility.

For data removal requests, contact <dataforleads@gmail.com>. Please use Extract Emails Phone Social Media From Website responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

## `targetUrls` (type: `array`):

List of target website URLs to scrape for contact information.

## `enablePhoneExtraction` (type: `boolean`):

If enabled, the scraper will also extract phone numbers found on the pages.

## `enableSocialMediaExtraction` (type: `boolean`):

If enabled, the scraper will detect and extract social media profile links (e.g., LinkedIn, Twitter, Facebook).

## `proxySettings` (type: `object`):

Configuration for proxies. Using residential proxies is highly recommended to avoid blocking.

## Actor input object example

```json
{
  "targetUrls": [
    {
      "url": "https://apify.com"
    }
  ],
  "enablePhoneExtraction": true,
  "enableSocialMediaExtraction": true,
  "proxySettings": {
    "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 = {
    "targetUrls": [
        {
            "url": "https://apify.com"
        }
    ],
    "proxySettings": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/extract-emails-phone-social-media-from-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 = {
    "targetUrls": [{ "url": "https://apify.com" }],
    "proxySettings": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/extract-emails-phone-social-media-from-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 '{
  "targetUrls": [
    {
      "url": "https://apify.com"
    }
  ],
  "proxySettings": {
    "useApifyProxy": true
  }
}' |
apify call scraperoka/extract-emails-phone-social-media-from-website --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperoka/extract-emails-phone-social-media-from-website",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Extract Emails Phone Social Media From Website",
        "description": "🌐 Extract Emails, Phone & Social Media from Websites with precision. Automatically collect contact details for lead generation, outreach, and B2B research—faster, cleaner, and compliant. 🚀 Ideal for sales & marketing teams.",
        "version": "1.0",
        "x-build-id": "KQ71RCkzZgEkshyde"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~extract-emails-phone-social-media-from-website/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-extract-emails-phone-social-media-from-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-phone-social-media-from-website/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-extract-emails-phone-social-media-from-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-phone-social-media-from-website/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-extract-emails-phone-social-media-from-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": [
                    "targetUrls"
                ],
                "properties": {
                    "targetUrls": {
                        "title": "Target Websites",
                        "type": "array",
                        "description": "List of target website URLs to scrape for contact information.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "enablePhoneExtraction": {
                        "title": "Enable Phone Extraction",
                        "type": "boolean",
                        "description": "If enabled, the scraper will also extract phone numbers found on the pages.",
                        "default": true
                    },
                    "enableSocialMediaExtraction": {
                        "title": "Enable Social Media Extraction",
                        "type": "boolean",
                        "description": "If enabled, the scraper will detect and extract social media profile links (e.g., LinkedIn, Twitter, Facebook).",
                        "default": true
                    },
                    "proxySettings": {
                        "title": "Proxy Settings",
                        "type": "object",
                        "description": "Configuration for proxies. Using residential proxies is highly recommended to avoid blocking."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
