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

📇 Extract Contact Details pulls emails, phone numbers & key contact info from websites and profiles. ✅ Perfect for B2B outreach, lead generation, sales, and recruiting—save time, improve accuracy, and reach the right people faster.

- **URL**: https://apify.com/scraperoka/extract-contact-details.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Agents
- **Stats:** 1 total users, 0 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 Contact Details 🚀

Manually visiting websites to collect emails, phone numbers, and social links wastes hours you don’t have. **Extract Contact Details** automates contact data extraction for marketers, recruiters, growth teams, and researchers—at the scale of thousands of records in minutes (depending on your inputs).

---

### What You Get: Sample Output

Here's a sample record from a single run:

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

| Field | Type | What It Tells You |
|---|---|---|
| `domain` | string | The website domain the run scanned, so you can map results back to the company. |
| `homepage_url` | string | A convenient link to the homepage for quick verification. |
| `emails` | array | The email addresses found on the website (with confidence and source info). |
| `emails[].email` | string | The extracted email address you can use for outreach or CRM enrichment. |
| `emails[].confidence_score` | number | A confidence signal indicating how strongly the extraction matched a contact email. |
| `emails[].source_url` | string | The page where the email was discovered—great for auditing and list cleanup. |
| `emails[].source_type` | string | Helps you understand whether the email likely came from a contact/about/footer area. |
| `emails[].validation_status` | string | Email status returned by the actor (for example, `unknown` in the sample). |
| `phone_numbers` | array | Phone numbers found on the pages (only when phone extraction is enabled). |
| `phone_numbers[].phone` | string | The extracted phone number. |
| `phone_numbers[].formatted` | string | A formatted version of the phone number when available. |
| `phone_numbers[].source_url` | string | The page where the phone number was discovered. |
| `social_media` | array | Deduplicated social profile links detected on the site (only when social extraction is enabled). |
| `social_media[].platform` | string | The social platform label for each profile (for example, LinkedIn or Twitter). |
| `social_media[].url` | string | The social profile URL you can click immediately. |
| `social_media[].source_url` | string | The page where the social link was found. |
| `error_message` | (not in dataset sample) | If an error occurs, the actor pushes a result record with empty arrays for emails, phones, and social. |

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

***

### Why Extract Contact Details?

There are a lot of ways to pull contact data from websites—here’s what sets **Extract Contact Details** (contact data extraction, lead contact extraction, and automated contact extraction) apart.

#### Contact Extraction Focused on Real Website Signals

**Extract Contact Details** extracts emails, phone numbers, and social media profile links from the pages you provide. It’s designed for web scraping contact details that you can use right away for CRM contact extraction and outreach workflows.

#### Flexible Input for Bulk Domain Lists

You can submit multiple `targetUrls` in one run and get a structured output per domain. This makes it ideal for extract contact information at scale rather than one-off manual searches.

#### Resilient Runs with Built-In Error Handling

The actor includes error handling so that if scraping fails for one domain, you still receive a result record with empty fields instead of losing the entire batch. That’s helpful when you’re building large lead contact extraction datasets.

#### Clean, Consistent Output for Downstream Use

Results are pushed to the Apify dataset with consistent field names (`domain`, `homepage_url`, `emails`, `phone_numbers`, `social_media`). This makes contact details data extraction easier to integrate into pipelines, spreadsheets, and CRM imports.

***

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---:|---|
| `targetUrls` | ✅ | List of target website URLs to scrape for contact information. Each item is an object with a `url`. |
| `enablePhoneExtraction` | ⬜ | If enabled, the scraper will also extract phone numbers found on the pages. |
| `enableSocialMediaExtraction` | ⬜ | If enabled, the scraper detects and extracts social media profile links (for example, LinkedIn, Twitter, Facebook). |
| `proxySettings` | ⬜ | Proxy configuration to help the run stay reliable while scraping publicly available data. |
| ↳ `proxySettings.proxy support` | ⬜ | When set in `proxySettings`, it enables Apify Proxy usage. |

***

### Core Capabilities

#### Multi-Domain Contact Data Extraction

Feed in multiple websites via `targetUrls`, and **Extract Contact Details** returns one structured result per domain. You’ll get emails, phone numbers, and social links depending on which extraction options you enable.

#### Extract Emails, Phone Numbers, and Social Profiles

The actor extracts email addresses, phone numbers (when enabled), and social media profile links (when enabled) from the pages of each target domain. This supports everything from extract contact information to automated contact extraction for outreach and research.

#### Deduplicated Social Media Links

For `social_media`, links are deduplicated so you don’t receive repeated profiles. This helps keep your lead contact extraction clean and easier to import into a CRM.

#### Output That’s Ready for Analysis

Each dataset record includes `domain`, `homepage_url`, and consistent arrays for `emails`, `phone_numbers`, and `social_media`. With source URLs attached to emails, phones, and socials, you can audit and refine your lists without guesswork.

#### Proxy Support for Reliable Scraping

The actor supports proxy settings through `proxySettings`, and residential proxies are recommended to avoid blocking. This is especially useful for web scraping contact details across larger batches.

***

### Who Gets the Most Out of This

Here's how different teams put **Extract Contact Details** to work:

**Sales Development Representatives** — Use automated contact extraction to turn a list of target company websites into outreach-ready email sets, plus phone numbers and social links when available. The result is faster prospecting and cleaner lists for follow-up sequences.

**Marketers & Growth Teams** — Build lead contact extraction datasets from competitor or partner sites, then enrich campaigns with verified sources by keeping `source_url` attached to each email and contact detail.

**Recruiters & Talent Sourcers** — Extract contact details from company websites to reach hiring teams, support desks, or recruiting offices, and capture social profiles for multi-channel engagement.

**Researchers & Data Analysts** — Use contact data extraction for dataset building and analysis, since each domain’s output includes consistent fields that map neatly into spreadsheets and analytics workflows.

**Automation & Integration Specialists** — When your pipeline needs structured CRM contact extraction output, the actor’s consistent dataset schema makes it straightforward to consume via Apify dataset exports and programmatic access.

***

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

No coding needed. Here's how to run **Extract Contact Details** from start to finish:

1. **Open the actor on Apify** — visit <https://console.apify.com> and open the actor page.
2. **Enter your inputs** — add your list in `targetUrls`, and set `enablePhoneExtraction` / `enableSocialMediaExtraction` based on what you want.
3. **Configure proxy settings** — if you’re running larger batches, enable proxy usage in `proxySettings` for smoother scraping.
4. **Hit Run and watch the live log** — monitor progress per domain in the actor logs.
5. **View results in the dataset tab** — each domain produces a structured record with `emails`, `phone_numbers`, and `social_media`.
6. **Export as JSON, CSV, or Excel** — download directly from the Apify dataset view.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Extract Contact Details** plugs directly into your existing workflow.

You can export results from the Apify dataset tab in common formats like JSON, CSV, or Excel. This makes it easy to move contact details data extraction output into spreadsheets and analysis tools.

You can also connect your workflow using Apify’s platform capabilities such as API access, webhooks, and no-code automation tools like Zapier or Make, so your scraped emails, phone numbers, and social profiles can automatically update downstream systems. For more details on these options, refer to the Apify documentation and API docs at <https://apify.com/docs/api>.

***

### Pricing & Free Trial

**Extract Contact Details** runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can start with a small test batch to confirm the output quality for your target domains.

For real runs, pricing is based on Apify compute units (CU) and Apify plans. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limit sensitivity | Proxy support and stable execution patterns for web scraping contact details. |
| Blocking risk | Built-in proxy settings help reduce interruptions when scraping publicly available data. |
| Per-domain failures | If one domain errors, the actor still pushes a result record for that domain with empty arrays. |
| Output consistency | Dataset records keep the same structure (`domain`, `homepage_url`, `emails`, `phone_numbers`, `social_media`). |
| Scale across lists | Processes multiple `targetUrls` in one run to support lead contact extraction workflows. |
| Deduplication | Social profile links are deduplicated by canonicalized URL. |

**Limitations:** The actor extracts from publicly available content on the pages it scans; login-gated or private profiles aren’t accessible. If a site doesn’t publish contact emails or phone numbers, the corresponding arrays may be empty.

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

***

### Frequently Asked Questions

#### Is there a free plan or trial for Extract Contact Details?

Yes, Apify offers a free tier that you can use to run **Extract Contact Details** and test the output on a small set of websites before scaling up.

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

No. This actor extracts contact data from publicly available sources. It doesn’t require you to log in to the target websites.

#### How accurate is the contact data extracted by Extract Contact Details?

Accuracy depends on what the website publishes. The actor extracts emails, phone numbers, and social profile links it finds on the provided domains and returns structured results with source URLs for transparency.

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

Your results depend on how many `targetUrls` you provide and what contact information exists on those sites. The actor also limits pages per domain as part of its run configuration.

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

The data freshness depends on when you run the actor. Each run scrapes the current publicly available pages and produces a dataset snapshot at that time.

#### Is it legal to use Extract Contact Details for contact data extraction?

This actor works with **publicly available data**. It’s your responsibility to comply with applicable laws and regulations (including GDPR/CCPA where relevant) and to respect platform terms when storing and using any extracted contact details.

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

Yes. You can export from the Apify dataset in formats like CSV or Excel, then import into Google Sheets or other tools. You can also use automation and integration options via Apify to push data into your systems.

#### Can I run Extract Contact Details on a schedule automatically?

Yes. You can set up scheduled runs using Apify capabilities, so **Extract Contact Details** runs automatically on a cron schedule.

#### Can I access the results via API?

Yes. You can access actor runs and dataset results programmatically using the Apify API. See <https://apify.com/docs/api> for details.

#### What happens if the actor hits an error for a domain?

If an error occurs for a domain, the actor pushes a result record for that domain with empty `emails`, `phone_numbers`, and `social_media`. The run continues for other domains to avoid losing your whole batch.

***

### Need Help or Have a Request?

Got a question about **Extract Contact Details** or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help with setup questions and we actively maintain the actor based on user feedback. Feature ideas you might request include webhook notifications on completion and batch improvements for faster CRM contact extraction.

***

### Disclaimer & Responsible Use

*Extract Contact Details is the fastest, most reliable way to extract contact details from publicly available sources—start your free run today.*

This actor extracts **publicly available data** from websites and does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform terms of service, and any applicable regulations when you store and use the extracted contact data. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful 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("scraperoka/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("scraperoka/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 scraperoka/extract-contact-details --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperoka/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 pulls emails, phone numbers & key contact info from websites and profiles. ✅ Perfect for B2B outreach, lead generation, sales, and recruiting—save time, improve accuracy, and reach the right people faster.",
        "version": "1.0",
        "x-build-id": "gDUlydOtYUglHTP3T"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~extract-contact-details/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-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/scraperoka~extract-contact-details/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-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/scraperoka~extract-contact-details/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
