# Extract Contact Details (`scrapers-hub/extract-contact-details`) Actor

📇 Extract contact details with extract-contact-details—automatically pull emails, phone numbers & social profiles from target pages. 🚀 Perfect for lead gen, outreach, and B2B sales research. ✅ Save time, boost accuracy, enrich your CRM!

- **URL**: https://apify.com/scrapers-hub/extract-contact-details.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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Contact Details 🔍

**Extract Contact Details** is an automated contact details extraction tool that scrapes websites to find email addresses, phone numbers, and social media profile links. If you’re looking for extract contact data for B2B outreach, CRM contact enrichment, or lead contact details extraction, this actor helps you do it at scale—saving you hours of manual research with contact information scraping from publicly available data.

Whether you’re a marketer, recruiter, researcher, or data analyst, **Extract Contact Details** supports contact details extraction workflows by returning structured results you can immediately use in spreadsheets, data pipelines, and CRM imports.

---

### Why choose Extract Contact Details?

| Feature | Benefit |
| --- | --- |
| ✅ **All-in-one contact extraction** | Extracts emails, phone numbers, and social media profile links in one run |
| ✅ **Built-in reliability with fallbacks** | Includes retries and fallback logic for resilience during scraping |
| ✅ **Configurable phone + social collection** | Control whether you want phone numbers and social media links |
| ✅ **Structured JSON dataset output** | Produces consistent fields like `domain`, `homepage_url`, `emails`, `phone_numbers`, and `social_media` |
| ✅ **Scales across multiple domains** | Processes each provided target site and pushes results into the dataset |
| ✅ **Proxy support** | Uses your proxy settings to help reduce blocking and improve successful runs |

---

### Key features

- 🔐 **Accurate email extraction**: Extracts email addresses and returns email-level metadata like confidence score, source URL, and validation status
- 📞 **Optional phone number extraction**: When enabled, extracts phone numbers found on scraped pages
- 🌐 **Social media profile detection**: When enabled, extracts social media profile links and returns their platform, URL, and source
- 🧾 **Structured dataset results**: Each domain is pushed to the dataset with `domain`, `homepage_url`, `emails`, `phone_numbers`, and `social_media`
- 🛡️ **Resilience for real-world sites**: Includes retries and fallback behavior to improve outcomes
- 🧩 **Proxy configuration support**: Helps you run large batches using your proxy settings (residential proxies recommended)
- 💾 **Automated, immediate data saving**: Results are pushed to the Apify dataset as each domain completes
- 🔄 **Deduplicated social links**: Social results are deduplicated to avoid repeated profiles

---

### 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. Each entry should include a `url`. |
| `enablePhoneExtraction` | No | If `true`, the actor also extracts phone numbers found on the pages. Default is `true`. |
| `enableSocialMediaExtraction` | No | If `true`, the actor detects and extracts social media profile links (for example LinkedIn, Twitter, Facebook). Default is `true`. |
| `proxySettings` | No | Proxy configuration to help your scraping run reliably. Residential proxies are recommended to avoid blocking. |
| `proxySettings.proxy support` | No | When set to `true`, the actor will use Apify Proxy. (This option is prefilled as `true`.) |

> Note: `targetUrls` is the only required input field.

***

### Output

After execution, the actor pushes results to the Apify dataset as JSON objects—one per scraped domain. The dataset transformation fields are `domain`, `homepage_url`, `emails`, `phone_numbers`, and `social_media`.

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

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `domain` | string | The extracted domain for the target site that was scanned |
| `homepage_url` | string | The homepage URL formatted as `https://{domain}` |
| `emails` | array | Extracted email objects (email contact details extraction) |
| `emails[].email` | string | The email address that was found |
| `emails[].confidence_score` | number | Confidence score for the extracted email |
| `emails[].source_url` | string | Page URL where the email was found |
| `emails[].source_type` | string | Category/type of page where the email was discovered (e.g., contact-related page vs footer/body/header) |
| `emails[].validation_status` | string | Validation status for the email (e.g., valid/invalid/unknown/risky as returned by the actor) |
| `phone_numbers` | array | Extracted phone number objects (only when enabled) |
| `phone_numbers[].phone` | string | Raw phone number as extracted |
| `phone_numbers[].formatted` | string | Formatted phone number (when available) |
| `phone_numbers[].source_url` | string | Page URL where the phone number was found |
| `social_media` | array | Extracted social media profile objects (only when enabled) |
| `social_media[].platform` | string | Social platform name (e.g., LinkedIn/Twitter/Facebook, etc.) |
| `social_media[].url` | string | The detected social profile URL |
| `social_media[].source_url` | string | Page URL where the social link was found |
| `error_message` | (not exposed in dataset output) | The actor only pushes `error_message` in internal job models; the dataset records pushed in `main.py` contain no `error_message` field |

Export-wise: you can use the Apify dataset to download the results as JSON or CSV, depending on your workflow.

***

### How to use Extract Contact Details (via Apify Console)

1. **Open Apify Console**\
   Log in at [console.apify.com](https://console.apify.com) and go to the **Actors** section.

2. **Find the actor**\
   Search for **Extract Contact Details** and open the actor page.

3. **Add your target sites in the INPUT panel**\
   In **INPUT**, add one or more entries under `targetUrls`. Each entry must include a `url` (for example `https://yourdomain.com`).

4. **Choose what contact details to extract**\
   Enable or disable:
   - `enablePhoneExtraction` (phone number extraction)
   - `enableSocialMediaExtraction` (social media profile links)

5. **Configure proxies (recommended for reliable runs)**\
   In **Proxy Settings**, set `proxySettings.proxy support` according to your needs. Using residential proxies is highly recommended to avoid blocking.

6. **Run the actor**\
   Click **Run**. During execution, you’ll see logs indicating progress per domain (and whether phone/social extraction is enabled).

7. **Review results in the dataset**\
   After completion, open the **Dataset** tab. Each domain record includes `domain`, `homepage_url`, `emails`, `phone_numbers`, and `social_media`.

8. **Export your data**\
   Download the dataset results (JSON/CSV) and import them into your CRM, spreadsheets, or analysis pipeline.

No coding required—get accurate contact details extraction results in minutes. 🚀

***

### Advanced features & SEO optimization

- 🤖 **Engineered for Extract Contact Details**: Built specifically for contact information scraping workflows where you need emails, phone numbers, and social links together.
- 🧠 **Works well for CRM contact details extraction**: Confidence scores and source metadata help you decide which leads to prioritize.
- 🧰 **Input-driven automation**: Feed multiple websites at once via `targetUrls` to automatically extract contact details across domains.
- 🔎 **Public-data focused extraction**: Extracts emails and profile links from publicly available sources, keeping your pipeline clean and consistent.
- 🧱 **Structured results for easy ingestion**: The dataset schema is ready for downstream processing without extra reshaping.

***

### Best use cases

- 📈 **Lead generation teams**: Automatically extract contact details for outreach by collecting emails, phones, and social links from company sites
- 🧪 **Market researchers**: Build contact information scraping datasets across multiple brands for segmentation and analysis
- 🎯 **Recruiters**: Gather lead contact details extraction output to speed up sourcing from organizations’ public pages
- 💼 **Sales and BD**: Enrich account lists with CRM contact details extraction, combining website emails with phone and social references
- 🗂️ **Data analysts**: Analyze contact coverage by domain using confidence scores and source metadata from each extraction run
- 🧠 **Content and PR teams**: Extract contact data for press outreach by pulling emails and social profiles from target websites
- 🔗 **Developer workflows**: Use the actor’s structured JSON dataset output as an input step in larger automation pipelines for extract contact information

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `targetUrls`: array of objects with `url`
- **Proxy Support**
  - ✅ Uses `proxySettings.proxy support` when provided
  - ✅ Designed to work with residential proxies (recommended)
- **Retry Mechanism**
  - ✅ Includes retries and fallback logic for resilience
- **Dataset Structure**
  - ✅ One dataset record per scraped domain with:
    - `domain`, `homepage_url`, `emails`, `phone_numbers`, `social_media`
- **Rate Limits & Performance**
  - ✅ Actor is configured to cap the scraping depth per run using internal page limits (high-level)
- **Limitations**
  - ❌ If no valid domains are derived from `targetUrls`, the actor will stop with warnings
  - ❌ Extraction depends on what contact details exist on publicly available pages

***

### FAQ

#### What does Extract Contact Details extract from websites?

✅ It extracts emails, phone numbers (when `enablePhoneExtraction` is enabled), and social media profile links (when `enableSocialMediaExtraction` is enabled) from publicly available web content related to each target domain.

#### Do I need to provide full URLs or just domains?

You provide URLs in `targetUrls`. The actor parses and derives the domain internally from what you submit, then builds `homepage_url` as `https://{domain}`.

#### Can I extract phone numbers and social media links together?

✅ Yes. You can enable both `enablePhoneExtraction` and `enableSocialMediaExtraction` to get emails, phone numbers, and social links in a single run.

#### What does the `confidence_score` mean for extracted emails?

✅ `confidence_score` is included in each `emails[]` entry. It’s a numeric confidence value returned alongside the email, plus metadata like `source_url`, `source_type`, and `validation_status`.

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

✅ The actor pushes each domain result directly into the Apify dataset. Each record includes `domain`, `homepage_url`, `emails`, `phone_numbers`, and `social_media`.

#### Do I need any special authentication to use this actor?

✅ No authentication is required in the actor input. It focuses on extracting contact details from publicly available sources, but outcomes depend on what’s discoverable on the target sites.

#### Can this actor help with GDPR or data removal requests?

❌ You should apply your own compliance checks and legal responsibilities when using extracted contact information. If you need data removal help, contact <dataforleads@gmail.com>.

#### Is there an API or code integration available?

💻 The actor runs in Apify and writes structured dataset results. You can integrate it via Apify’s platform features, then consume the dataset output in your own automation or data pipeline.

***

### Support & feature requests

If you want to improve Extract Contact Details (or report an issue), tell us what you need for extract contact data workflows—especially around CRM contact details extraction and lead contact details extraction.

- 💡 **Feature Requests**: Ideas like CSV export enhancements, additional formatting for phone numbers, or expanding social media normalization would be great additions.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for future upgrades to Extract Contact Details.

***

### *Extract Contact Details* — Final thoughts

*Extract Contact Details* is built to make contact information scraping fast and structured at scale—so you can extract contact details with far less manual effort.

***

### Disclaimer

**This tool accesses *publicly accessible sources*** to extract contact details such as emails, phone numbers, and social media profile links. 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 honoring each website’s Terms of Service and applicable anti-spam rules.

For data removal requests, contact <dataforleads@gmail.com>. Please use Extract Contact Details 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("scrapers-hub/extract-contact-details").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("scrapers-hub/extract-contact-details").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 scrapers-hub/extract-contact-details --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapers-hub/extract-contact-details",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Extract Contact Details",
        "description": "📇 Extract contact details with extract-contact-details—automatically pull emails, phone numbers & social profiles from target pages. 🚀 Perfect for lead gen, outreach, and B2B sales research. ✅ Save time, boost accuracy, enrich your CRM!",
        "version": "1.0",
        "x-build-id": "DxTrSVEYGaexmVm9I"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~extract-contact-details/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-extract-contact-details",
                "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-contact-details/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-extract-contact-details",
                "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-contact-details/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-extract-contact-details",
                "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
