# Contact Info Scraper Pro (`concise_cafe/contact-info-scraper-pro`) Actor

Extract emails, phones & socials from any website. Validated data, one clean record per company.

- **URL**: https://apify.com/concise\_cafe/contact-info-scraper-pro.md
- **Developed by:** [andrew](https://apify.com/concise_cafe) (community)
- **Categories:** Lead generation, SEO tools, AI
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## Contact Info Scraper Pro

Extract emails, phone numbers, and social media profiles from any website. 6x faster than alternatives. Validated data, one clean record per company.

### What it does

Contact Info Scraper Pro crawls websites and extracts contact information — then validates, deduplicates, and merges everything into **one clean record per domain**.

No more spreadsheets full of duplicate rows and fake phone numbers. You get structured, validated contact data ready for outreach, CRM import, or lead generation.

### Benchmarks

Tested head-to-head against the market-leading contact scraper on the same 3 websites:

| Metric | Contact Info Scraper Pro | Market leader |
|--------|--------------------------|---------------|
| Total time (3 sites) | **9 seconds** | 57 seconds |
| Emails found (basecamp.com) | **3** | 2 |
| Emails found (ahrefs.com) | **2** | 2 |
| Social profiles (ahrefs.com) | **27** | 7 |

**6x faster. More contacts found. Cleaner output.**

### Key features

- **Per-domain merge** — All contacts from a website consolidated into a single record. One company = one row.
- **Phone validation** — Every number validated through libphonenumber (Google's phone library). Valid numbers formatted in E.164. Invalid numbers separated into `phonesUncertain`.
- **Email classification** — Each email tagged as `personal` (john@company.com) or `generic` (info@, support@, noreply@). Use `personalEmailsOnly` to get only real person addresses.
- **Confidence scoring** — Every contact scored `high`, `medium`, or `low` based on extraction source. Filter by your own quality threshold.
- **Skip empty results** — Enable `skipEmpty` to exclude domains with zero contacts from output. Every row in your dataset has actual data.
- **Smart crawling** — Prioritizes /contact, /about, /team, /impressum, and footer links before crawling other pages. Finds contacts where they actually are.
- **11 social platforms** — LinkedIn, Twitter/X, Facebook, Instagram, YouTube, TikTok, Telegram, Pinterest, Discord, Snapchat, Threads.
- **Hybrid crawler** — Lightweight HTTP for simple pages, full Playwright browser for JavaScript-heavy sites. Fast and cost-efficient.
- **Two output modes** — `per-domain` (merged, default) or `per-page` (one row per page, legacy compatible).
- **All export formats** — JSON, CSV, Excel, XML, HTML via Apify dataset.

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | *required* | List of URLs to scrape. Supports direct URLs and files. |
| `maxRequests` | integer | `100` | Maximum total pages to crawl across all start URLs. |
| `maxRequestsPerStartUrl` | integer | `2` | Maximum pages to crawl per start URL domain. |
| `maxDepth` | integer | `2` | Maximum link depth from the start URL. |
| `sameDomain` | boolean | `true` | Only follow links within the same domain. |
| `considerChildFrames` | boolean | `true` | Extract contacts from iframes on the page. |
| `outputMode` | string | `per-domain` | Output format: `per-domain` (one record per company) or `per-page` (one record per page). |
| `minConfidence` | string | `low` | Minimum confidence level for contacts to be included: `high`, `medium`, or `low`. |
| `skipEmpty` | boolean | `false` | Skip domains that have no contacts found. Keeps your output clean — only rows with actual data. |
| `personalEmailsOnly` | boolean | `false` | Only include personal emails (john@company.com). Filters out generic addresses like info@, support@, noreply@. |
| `proxyConfig` | object | Apify Proxy | Proxy configuration. Uses Apify Proxy by default. |

### Output format

#### Per-domain mode (default)

One record per domain with all contacts merged and deduplicated:

```json
{
  "domain": "example.com",
  "topLevelUrl": "https://example.com",
  "pagesScanned": 8,
  "emails": [
    {
      "value": "john@example.com",
      "type": "personal",
      "confidence": "high",
      "source": "mailto",
      "sourceUrl": "https://example.com/contact"
    },
    {
      "value": "info@example.com",
      "type": "generic",
      "confidence": "high",
      "source": "mailto",
      "sourceUrl": "https://example.com"
    }
  ],
  "phones": [
    {
      "value": "+12125551234",
      "confidence": "high",
      "source": "tel_link",
      "sourceUrl": "https://example.com/contact"
    }
  ],
  "phonesUncertain": [
    {
      "value": "212-555-9999",
      "confidence": "low",
      "source": "regex_text",
      "sourceUrl": "https://example.com/about"
    }
  ],
  "socialProfiles": {
    "linkedIns": ["https://linkedin.com/company/example"],
    "twitters": ["https://twitter.com/example"],
    "facebooks": ["https://facebook.com/example"],
    "instagrams": ["https://instagram.com/example"],
    "youtubes": [],
    "tiktoks": [],
    "telegrams": [],
    "pinterests": [],
    "discords": [],
    "snapchats": [],
    "threads": []
  },
  "scrapedAt": "2026-04-01T12:00:00.000Z"
}
````

#### Per-page mode

One record per crawled page. Compatible with existing contact scraper integrations:

```json
{
  "url": "https://example.com/contact",
  "domain": "example.com",
  "depth": 1,
  "referrerUrl": "https://example.com",
  "emails": ["john@example.com", "info@example.com"],
  "phones": ["+12125551234"],
  "phonesUncertain": ["212-555-9999"],
  "linkedIns": ["https://linkedin.com/company/example"],
  "twitters": ["https://twitter.com/example"],
  "facebooks": [],
  "instagrams": [],
  "youtubes": [],
  "tiktoks": [],
  "pinterests": [],
  "discords": [],
  "snapchats": [],
  "telegrams": [],
  "threads": [],
  "emailDetails": [
    {
      "value": "john@example.com",
      "type": "personal",
      "confidence": "high",
      "source": "mailto"
    }
  ],
  "phoneDetails": [
    {
      "value": "+12125551234",
      "confidence": "high",
      "source": "tel_link"
    }
  ]
}
```

### Pricing

**$1.50 per 1,000 pages scraped.** Everything included — no browser surcharge, no proxy extras.

You pay only for pages that are successfully processed. No subscription, no minimum, no hidden fees.

| Volume | Cost |
|--------|------|
| 100 pages | $0.15 |
| 1,000 pages | $1.50 |
| 10,000 pages | $15.00 |
| 100,000 pages | $150.00 |

### Use cases

#### Sales outreach

Feed a list of prospect websites and get validated email addresses with personal/generic classification. Focus your outreach on emails that get replies.

#### Lead generation at scale

Process thousands of company websites in a single run. Get one clean row per company with all contact details merged — ready to import into your CRM or outreach tool.

#### CRM enrichment

Fill in missing emails, phones, and social profiles for your existing accounts. Export to CSV or Excel and merge with your database.

#### Market research

Map contact information across an industry or competitor landscape. Use per-domain mode to get a clean company-level dataset.

#### Recruiting

Extract contact details from company team and career pages. Find direct emails instead of generic HR addresses.

### FAQ

#### How is this different from other contact scrapers?

Most contact scrapers give you one row per page — scrape a 10-page website and you get 10 rows of scattered, duplicated data. Phone numbers are unvalidated regex matches, and there's no way to tell personal emails from generic ones.

Contact Info Scraper Pro merges all contacts per domain, validates every phone number with libphonenumber, classifies emails as personal or generic, and scores confidence on every data point. You get clean data without manual cleanup.

#### What does the confidence score mean?

- **High:** Contact found in a `mailto:` link, `tel:` link, or schema.org structured data. Very likely to be real.
- **Medium:** Contact found in visible text near recognizable patterns (e.g., email next to "Contact us"). Probably real.
- **Low:** Contact matched by regex from general page text. May include false positives.

Use the `minConfidence` input parameter to filter. Set it to `medium` or `high` if you want only reliable data.

#### Does it handle JavaScript-rendered websites?

Yes. The hybrid crawler automatically detects when a page needs browser rendering (SPAs, dynamic content) and switches to Playwright. Simple HTML pages are processed with a fast HTTP crawler to save time and cost.

#### Can I use my existing input format from other contact scrapers?

Yes. The input parameters (`startUrls`, `maxDepth`, `maxRequests`, `sameDomain`, `proxyConfig`) are compatible with the standard contact scraper interface. Switch to per-page output mode for full backward compatibility.

#### What about GDPR?

This tool extracts publicly available contact information from websites. It does not store data — all results go to your Apify dataset, which you control. Compliance with data protection regulations (GDPR, CCPA, etc.) is the responsibility of the user. Use scraped data in accordance with applicable laws.

#### What are the limits?

- Maximum crawl depth and page limits are configurable via input parameters
- The scraper respects `robots.txt` by default
- It does not bypass CAPTCHAs, Cloudflare, or other anti-bot protections
- It does not extract contacts from PDFs or images
- It does not fill out contact forms

### Technical details

- **Language:** TypeScript
- **Framework:** Crawlee (Apify SDK v3) with AdaptivePlaywrightCrawler
- **Phone validation:** google-libphonenumber
- **Domain parsing:** tldts
- **Browser:** Playwright (auto-detected when needed)

### Changelog

See [Apify Store](https://apify.com/) for version history and updates.

### License

ISC

# Actor input Schema

## `startUrls` (type: `array`):

List of URLs to scrape. Supports direct URLs, files (one URL per line), and Google Sheets.

## `maxRequests` (type: `integer`):

Maximum total number of pages to crawl across all start URLs. For runs > 1000 pages, recommended Actor memory is 1024 MB+.

## `maxRequestsPerStartUrl` (type: `integer`):

Maximum number of pages to crawl per each start URL. Default 2 = start page + contact/about page. Increase for deeper crawling.

## `maxDepth` (type: `integer`):

How many links deep from the start URL the crawler will go. Contact/about pages are always crawled regardless of this setting.

## `sameDomain` (type: `boolean`):

If enabled, only links within the same domain as the start URL will be followed.

## `minConfidence` (type: `string`):

Filter contacts by confidence level. 'high' = only verified contacts (mailto/tel links, schema.org). 'medium' = includes visible text matches. 'low' = includes all regex matches.

## `skipEmpty` (type: `boolean`):

If enabled, domains with no emails, phones, or social profiles found will not be included in the output.

## `personalEmailsOnly` (type: `boolean`):

If enabled, only personal emails are returned (generic addresses like info@, support@, etc. are filtered out).

## `proxyConfig` (type: `object`):

Proxy settings. Use Apify Proxy or your own proxy URLs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://apify.com"
    }
  ],
  "maxRequests": 100,
  "maxRequestsPerStartUrl": 2,
  "maxDepth": 2,
  "sameDomain": true,
  "minConfidence": "low",
  "skipEmpty": true,
  "personalEmailsOnly": false,
  "proxyConfig": {
    "useApifyProxy": true
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://apify.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("concise_cafe/contact-info-scraper-pro").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "startUrls": [{ "url": "https://apify.com" }] }

# Run the Actor and wait for it to finish
run = client.actor("concise_cafe/contact-info-scraper-pro").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://apify.com"
    }
  ]
}' |
apify call concise_cafe/contact-info-scraper-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=concise_cafe/contact-info-scraper-pro",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Contact Info Scraper Pro",
        "description": "Extract emails, phones & socials from any website. Validated data, one clean record per company.",
        "version": "1.0",
        "x-build-id": "3E8nOYJLENZcVRXHv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/concise_cafe~contact-info-scraper-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-concise_cafe-contact-info-scraper-pro",
                "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/concise_cafe~contact-info-scraper-pro/runs": {
            "post": {
                "operationId": "runs-sync-concise_cafe-contact-info-scraper-pro",
                "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/concise_cafe~contact-info-scraper-pro/run-sync": {
            "post": {
                "operationId": "run-sync-concise_cafe-contact-info-scraper-pro",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of URLs to scrape. Supports direct URLs, files (one URL per line), and Google Sheets.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxRequests": {
                        "title": "Max pages to scrape",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum total number of pages to crawl across all start URLs. For runs > 1000 pages, recommended Actor memory is 1024 MB+.",
                        "default": 100
                    },
                    "maxRequestsPerStartUrl": {
                        "title": "Max pages per start URL",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of pages to crawl per each start URL. Default 2 = start page + contact/about page. Increase for deeper crawling.",
                        "default": 2
                    },
                    "maxDepth": {
                        "title": "Max crawl depth",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many links deep from the start URL the crawler will go. Contact/about pages are always crawled regardless of this setting.",
                        "default": 2
                    },
                    "sameDomain": {
                        "title": "Stay on the same domain",
                        "type": "boolean",
                        "description": "If enabled, only links within the same domain as the start URL will be followed.",
                        "default": true
                    },
                    "minConfidence": {
                        "title": "Minimum confidence level",
                        "enum": [
                            "high",
                            "medium",
                            "low"
                        ],
                        "type": "string",
                        "description": "Filter contacts by confidence level. 'high' = only verified contacts (mailto/tel links, schema.org). 'medium' = includes visible text matches. 'low' = includes all regex matches.",
                        "default": "low"
                    },
                    "skipEmpty": {
                        "title": "Skip empty results",
                        "type": "boolean",
                        "description": "If enabled, domains with no emails, phones, or social profiles found will not be included in the output.",
                        "default": true
                    },
                    "personalEmailsOnly": {
                        "title": "Personal emails only",
                        "type": "boolean",
                        "description": "If enabled, only personal emails are returned (generic addresses like info@, support@, etc. are filtered out).",
                        "default": false
                    },
                    "proxyConfig": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Use Apify Proxy or your own proxy URLs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```