# Extract Contact Details (`solid-scraper/extract-contact-details`) Actor

📞 Extract contact details fast with targeted lead data for outreach, sales, and marketing. ✅ Find emails, phones & profiles quickly—save time, boost conversions, and reach the right prospects instantly. 🚀

- **URL**: https://apify.com/solid-scraper/extract-contact-details.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Lead generation, Automation
- **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 Contact Details 📬

**Extract Contact Details** is a website contact details scraper that automatically extracts **email addresses**, **phone numbers**, and **social media profile links** from public web pages. If you’re trying to solve the “how do I quickly build a leads list with verified-looking contact data extraction?” problem, this actor helps you run **bulk contact extraction** at scale—so you can enrich your CRM, speed up outreach, and save hours of manual copy-paste work.

---

### Why choose Extract Contact Details?

| Feature | Benefit |
| --- | --- |
| ✅ **All-in-one contact extraction** | Extract emails, phone numbers (optional), and social media links (optional) in one run |
| ✅ **Reliability with proxy support** | Uses built-in proxy support for reliable scraping on many websites |
| ✅ **Fallback-friendly execution** | Includes retries and fallbacks for resilience when pages are hard to access |
| ✅ **Structured dataset output** | Returns clean, consistent fields like `domain`, `emails`, `phone_numbers`, and `social_media` |
| ✅ **Scale-ready for multiple sites** | Processes multiple target website URLs you provide in a single job |
| ✅ **Easy export & automation** | Produces dataset records you can export to JSON/CSV for pipelines |

---

### Key features

- 🔍 **Email addresses extraction**: Collects email addresses and includes confidence and source metadata in the results  
- 📞 **Phone number extraction (optional)**: When enabled, extracts phone numbers found on the pages  
- 🌐 **Social media profile links (optional)**: Detects and extracts social media profile links and outputs them in a structured `social_media` object/array  
- 🧱 **Clean per-domain organization**: Each dataset record is grouped by `domain` with a `homepage_url` for quick reference  
- 🧾 **Source-aware results**: Each extracted email includes `source_url` and `source_type`, and phones include `source_url`  
- 🛡️ **Proxy support for smoother runs**: Helps reduce blocking risk by supporting proxy configuration (recommended: residential proxies)  
- 💾 **Immediate dataset pushing**: Each domain result is pushed to the Apify dataset as the run progresses  
- 🔁 **Resilience-oriented behavior**: Uses retries and fallbacks to keep extraction moving even when some pages error out  

---

### 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` | ✅ | List of target website URLs to scrape for contact information. The actor reads each entry’s `url`. |
| `enablePhoneExtraction` | ❌ | If `true`, the scraper also extracts phone numbers found on the pages. Defaults to `true`. |
| `enableSocialMediaExtraction` | ❌ | If `true`, the scraper detects and extracts social media profile links (e.g., LinkedIn, Twitter, Facebook). Defaults to `true`. |
| `proxySettings` | ❌ | Proxy configuration. Using residential proxies is highly recommended to avoid blocking. Includes `proxy support` (prefilled as `true`). |

Nested fields for `proxySettings`:

| Field | Required | Description |
| --- | --- | --- |
| `proxySettings.proxy support` | ❌ | `true` to enable Apify Proxy. Prefilled to `true` in the actor input UI. |

***

### Output

The actor saves each domain’s scraped contact details to the Apify dataset as JSON records with consistent fields.

Example dataset record:

```json
{
  "domain": "apify.com",
  "homepage_url": "https://apify.com",
  "emails": [
    {
      "email": "contact@example.com",
      "confidence_score": 85.0,
      "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/"
    }
  ],
  "social_media": [
    {
      "platform": "linkedin",
      "url": "https://www.linkedin.com/company/example",
      "source_url": "https://apify.com/"
    }
  ]
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `domain` | string | The scraped domain extracted from your provided URL(s). |
| `homepage_url` | string | The constructed homepage URL in the form `https://{domain}`. |
| `emails` | array | Extracted email objects for the domain. Each includes email and extraction metadata. |
| `emails[].email` | string | The extracted email address. |
| `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 | Where on the page the email was found (e.g., contact page, footer, header, or body). |
| `emails[].validation_status` | string | Validation status for the email (e.g., `valid`, `invalid`, `unknown`, `risky`). |
| `phone_numbers` | array | Extracted phone number objects (only when phone extraction is enabled). |
| `phone_numbers[].phone` | string | The extracted phone number. |
| `phone_numbers[].formatted` | string | Formatted phone representation (when available, e.g., E.164-style formatting). |
| `phone_numbers[].source_url` | string | Page URL where the phone number was found. |
| `social_media` | array | Extracted social media link objects (only when social extraction is enabled). |
| `social_media[].platform` | string | Social platform name (e.g., LinkedIn, Twitter, Facebook—depending on what’s found). |
| `social_media[].url` | string | The social profile link as found. |
| `social_media[].source_url` | string | Page URL where the social link was found. |

Tip: Once the run finishes, export the dataset to JSON or CSV from the Apify UI (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 open the Actors marketplace.

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

3. **Configure input**\
   In the **INPUT** section, add your websites under **Target Websites** (`targetUrls`).\
   Optionally toggle **Enable Phone Extraction** and **Enable Social Media Extraction**.

4. **Set proxy configuration (recommended)**\
   In **Proxy Configuration**, enable **Use Apify Proxy** if you want to use Apify Proxy. (The input is prefilled as `true`.)

5. **Run the actor**\
   Click **Run**. During execution you’ll see scanning logs per domain, plus success summaries for extracted emails, phones, and social links.

6. **Review progress**\
   Watch for any warnings if a URL/domain can’t be parsed or if a domain fails to scrape.

7. **Open the output dataset**\
   After completion, open the dataset from the **OUTPUT** tab to view the structured records with `domain`, `emails`, `phone_numbers`, and `social_media`.

No coding required—get **Extract Contact Details** results in minutes.

***

### Advanced features & SEO optimization

- ✨ **Engineered for contact data extraction**: Helps with contact detail extraction tasks like lead contact extraction, CRM contact data extraction, and bulk contact extraction from websites
- 🔄 **Email + phone + social in one pass**: You can turn phone and social extraction on/off depending on whether you’re doing email-only contact information scraper work or full outreach enrichment
- 🧰 **Data completeness for outreach workflows**: Outputs emails with `confidence_score`, `source_url`, and `validation_status`, plus phone and social data when enabled
- 🧾 **Domain-first organization**: Each record is keyed by `domain` with a `homepage_url`, making it easier to join results to downstream CRM pipelines
- 🛡️ **Resilience & proxy support**: Built-in proxy support and retries/fallbacks help keep large runs moving for automate contact detail extraction workflows

***

### Best use cases

- 📈 **B2B lead generation teams**: Enrich prospect lists by extracting email addresses and social profile links from target company websites
- 🧑‍💼 **Recruiters**: Automate contact data extraction for team pages and company contact pages when building outreach lists
- 🏢 **Sales ops & RevOps**: Improve CRM contact data extraction accuracy by using structured fields like `confidence_score` and `source_url`
- 🔬 **Researchers & analysts**: Perform contact information scraper studies by comparing extracted contact coverage across many domains
- 💡 **Marketing teams**: Speed up cold outreach prep by extracting phone numbers and emails (when enabled) alongside social media profile links
- 🛠️ **Developer workflows**: Use bulk contact extraction output for automated enrichment pipelines and exports to JSON/CSV
- 🗂️ **Website audit teams**: Validate whether contact pages expose emails, phone numbers, or social links consistently across a portfolio

***

### Technical specifications

- **Supported Input Formats**: ✅ Accepts `targetUrls` as an array of objects with a `url` string
- **Phone Extraction**: ✅ Controlled by `enablePhoneExtraction` (default `true`)
- **Social Extraction**: ✅ Controlled by `enableSocialMediaExtraction` (default `true`)
- **Proxy Support**: ✅ `proxySettings` with `proxy support` support (residential proxies recommended)
- **Retries & Fallbacks**: ✅ Includes retries and fallbacks for resilience
- **Dataset Structure**: ✅ One dataset record per scraped domain with `domain`, `homepage_url`, `emails`, `phone_numbers`, `social_media`
- **Limitations**: ❌ Private or restricted pages may not yield contact details because the actor targets publicly available sources only

***

### FAQ

#### What contact details can Extract Contact Details extract?

✅ It extracts **email addresses**, and it can also extract **phone numbers** and **social media profile links** depending on whether `enablePhoneExtraction` and `enableSocialMediaExtraction` are enabled.

#### Where does the actor store results?

✅ It pushes results directly into the Apify **dataset**. Each dataset record includes `domain`, `homepage_url`, `emails`, `phone_numbers`, and `social_media`.

#### What happens if a website fails to scrape?

❌ If a domain errors during scraping, the actor still pushes an empty result record for that domain (with empty `emails`, `phone_numbers`, and `social_media`).

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

✅ No coding required. You can run it directly in Apify Console by providing the required `targetUrls` and optional extraction/proxy toggles.

#### Can I extract emails only (without phones or social links)?

✅ Yes. Set `enablePhoneExtraction` to `false` and/or set `enableSocialMediaExtraction` to `false`.

#### Does the output include any confidence or source information for emails?

✅ Yes. Each extracted email record includes `confidence_score`, `source_url`, `source_type`, and `validation_status`.

#### What kind of websites can I use as input?

✅ You can provide any target website URLs. The actor extracts the domain from each provided `url` and organizes results by that domain for contact data extraction for contacts from business websites.

#### Is this suitable for bulk lead contact extraction?

✅ Yes. The actor supports multiple `targetUrls` in one run, making it useful for bulk contact extraction and CRM contact data extraction workflows.

***

### Support & feature requests

If you want to improve **Extract Contact Details** or request enhancements for contact data extraction, we’d love to hear from you.

- 💡 **Feature Requests**: Ideas like exporting directly to CSV, adding additional normalization options, or expanding which contact page types are captured are welcome.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap and makes **Extract Contact Details** even more useful for contact information scraper workflows.

***

### Closing CTA / Final thoughts

*Extract Contact Details* is the most practical and SEO-optimized way to automate **contact data extraction** from websites—delivering structured results you can turn into outreach-ready lists fast.

***

### Disclaimer

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

You are responsible for complying with applicable laws and regulations (including GDPR, CCPA, and relevant spam and privacy rules) and for respecting each website’s Terms of Service. For data removal requests, contact <dataforleads@gmail.com>.

Please use Extract Contact Details responsibly, ethically, and for legitimate purposes.

# 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("solid-scraper/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("solid-scraper/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 solid-scraper/extract-contact-details --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solid-scraper/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 fast with targeted lead data for outreach, sales, and marketing. ✅ Find emails, phones & profiles quickly—save time, boost conversions, and reach the right prospects instantly. 🚀",
        "version": "1.0",
        "x-build-id": "nKiDSzcNY0QcgHbI0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~extract-contact-details/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-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/solid-scraper~extract-contact-details/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-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/solid-scraper~extract-contact-details/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
