# Facebook Email Scraper (`solid-scraper/facebook-email-scraper`) Actor

📧 Facebook Email Scraper extracts verified emails from public profiles and pages—fast and targeted. Ideal for sales, marketers, and agencies seeking high-quality leads. 🚀 Enhance outreach with cleaner data and smarter prospecting.

- **URL**: https://apify.com/solid-scraper/facebook-email-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Facebook Email Scraper 📬

**Facebook Email Scraper** helps you collect email addresses tied to Facebook profiles by using your chosen **keywords** (and optional location + email-domain filters). It’s a purpose-built **facebook email scraper** for lead generation and outreach workflows—whether you’re looking for a **facebook contact email scraper**, **facebook lead email scraper**, or a way to **export emails from facebook** at scale—saving you hours of manual work.

---

### Why choose Facebook Email Scraper?

| Feature | Benefit |
|---|---|
| ✅ **Keyword-based scraping** | Finds email addresses mentioned in publicly available Facebook bios and posts related to your keywords. |
| ✅ **Email-domain targeting (customDomains)** | Filters results to the domains you care about (for example `@gmail.com`) for more relevant leads. |
| ✅ **Reliability with built-in proxy support** | Helps keep runs stable when requests are rate-limited or blocked. |
| ✅ **Resilience via retries and fallbacks** | Includes retries and fallback behavior to improve chances of getting usable results. |
| ✅ **Structured dataset output** | Saves each found email with fields like `network`, `keyword`, `title`, `description`, `url`, and `email`. |
| ✅ **Scale-controlled collection (maxEmails)** | Caps output using `maxEmails` so large runs don’t run indefinitely. |

---

### Key features

- 🔍 **Accurate email extraction from Facebook bios and posts**: Extracts email addresses from the publicly available text associated with your keywords.  
- 🏷️ **Targeted lead discovery with keywords**: Use a keyword list to guide what kinds of profiles and pages to focus on.  
- 🌐 **Custom email-domain filters**: Narrow results using `customDomains` so you primarily collect emails from the domains you want.  
- 🛡️ **Proxy-aware scraping**: Supports configured proxy settings for more reliable scraping runs.  
- 🔄 **Retries and fallback handling**: Includes logic to continue collecting data when some requests fail or return empty results.  
- 📊 **Clean, structured output per email**: Each match is pushed as a row with consistent fields for easy analysis and export.  
- 💾 **Progress persistence during runs**: Saves progress as it collects emails to reduce the impact of interruptions.  
- ⚙️ **Scale control with stop conditions**: Uses `maxEmails` to stop once enough emails are collected (without guaranteeing the exact target is always reached).  

---

### Input

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

```json
{
  "keywords": ["founder", "marketing"],
  "location": "",
  "platform": "Facebook",
  "customDomains": ["@gmail.com"],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {}
}
````

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `keywords` | ✅ | A list of keywords to search for. The scraper uses these terms to find email addresses mentioned in Facebook bios and posts related to your keywords. |
| `location` | ❌ | Location to filter search results. Leave empty to not apply a location filter. |
| `platform` | ❌ | Select platform. The only available option in this actor is `Facebook`. |
| `customDomains` | ❌ | List of custom email domains to target (for example `@gmail.com`). The scraper focuses on email addresses matching these domains. |
| `maxEmails` | ❌ | Maximum number of emails to collect. The scraper stops once this limit is reached. Setting a higher limit can increase coverage but doesn’t guarantee reaching the exact number. |
| `engine` | ❌ | Choose scraping engine. Available enum value is `legacy` (default). |
| `proxyConfiguration` | ❌ | Proxy settings for this Actor. Use this to configure how scraping requests are routed. |

***

### Output

The actor saves each found email as a structured JSON row (pushed via `Actor.push_data`). In practice, the dataset will contain one item per collected email match.

```json
{
  "network": "Facebook.com",
  "keyword": "marketing",
  "title": "Example result title",
  "description": "Example result description text",
  "url": "https://example.com/some-facebook-link",
  "email": "person@example.com",
  "proxyGroups": ["legacy"]
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `network` | string | The source network label for the result (always `Facebook.com`). |
| `keyword` | string | The keyword currently being used to collect this email. |
| `title` | string | Title associated with the scraped result. |
| `description` | string | Description/body text where the email was found. |
| `url` | string | The URL associated with the scraped result. |
| `email` | string | The extracted email address. |
| `proxyGroups` | array | The proxy configuration group list used for the run (as provided by the actor logic). |

After export, you can typically use the dataset in common formats like **JSON** and **CSV** from the Apify dataset UI.

***

### How to use Facebook Email Scraper (via Apify Console)

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

2. **Find the actor**\
   Search for **Facebook Email Scraper** in the Actors page.

3. **Go to the INPUT section**\
   Use the built-in form to enter your parameters (or paste a JSON structure like the example in the Input section).

4. **Set your keywords**\
   Add one or more keywords (required). For example, try combinations relevant to your niche (like “founder” and “marketing”) to support **facebook profile email scraper** workflows.

5. **Optional: narrow targeting**
   If you want a **facebook page email list** style dataset with cleaner deliverability, set `customDomains` (for example `@gmail.com`) and optionally fill `location`.

6. **Optional: adjust collection limits**
   Set `maxEmails` to control how many emails you want back from the run.

7. **Optional: configure proxy settings**
   If you’re running large campaigns, you can set `proxyConfiguration` for more reliable scraping.

8. **Run and monitor logs**
   Start the run and watch the live logs for progress and pushed results. The actor persists progress as it collects emails.

9. **Open the OUTPUT dataset and export**
   When the run completes, open the generated dataset to preview and export results (JSON/CSV).

No coding required—get accurate results in minutes with this **facebook email harvesting tool**.

***

### Advanced features & SEO optimization

- 🧠 **Engineered for “facebook lead email scraper” use cases**: Built around keyword-driven email discovery to support practical outreach lists like **find business email on facebook**.
- 🎯 **Domain-focused filtering for better targeting**: Use `customDomains` to collect emails from specific providers you trust, making your **facebook contact email scraper** output more usable.
- 💾 **Progress persistence for long runs**: Saves progress during execution so large searches are less risky to interrupt.
- 🌐 **Built-in proxy support for reliable scraping**: Helps maintain stability on runs that encounter blocks or throttling.
- 🔄 **Retries and fallbacks for resilience**: Includes retry logic and fallback handling to improve overall collection success.

***

### Best use cases

- 📈 **Lead generation**: Build a targeted email list by harvesting emails that appear in Facebook bios and posts related to your keywords.
- 🎓 **Market research**: Quickly compare email coverage across niches by running different keyword sets and analyzing the `keyword` field in results.
- ✉️ **Outreach & cold email campaigns**: Export emails from Facebook for segmented campaigns filtered by `customDomains`.
- 🧩 **CRM enrichment**: Feed structured rows into your pipeline by mapping `email`, `url`, and `keyword` fields to your lead objects.
- 🧪 **Data analysts**: Track how many distinct emails appear per keyword run and validate quality by reviewing `description` text.
- 🏢 **Business development teams**: Create a lightweight prospecting dataset to support a **facebook email crawler**-style workflow without manual searching.
- 💻 **Automation pipelines**: Use the dataset output to trigger downstream steps (deduping, validation, routing) after each run.

***

### Technical specifications

- **Supported Input Formats**\
  ✅ JSON input via `input.json` with fields: `keywords` (required), plus optional `location`, `platform`, `customDomains`, `maxEmails`, `engine`, and `proxyConfiguration`.

- **Proxy Support**\
  ✅ Yes—use the `proxyConfiguration` input to configure proxies for this Actor.

- **Retry Mechanism**\
  ✅ Yes—includes retry and fallback behavior to improve resilience during scraping.

- **Dataset Structure**\
  ✅ JSON dataset rows pushed with these keys: `network`, `keyword`, `title`, `description`, `url`, `email`, `proxyGroups`.

- **Rate Limits & Performance**\
  Performance depends on run size and response behavior. The input description notes that large searches or high email limits may take longer, and you can increase the timeout in Run Options (default: 3600 s / 1 hr).

- **Limitations**\
  ⚠️ Results depend on which emails are publicly mentioned in Facebook bios and posts related to your keywords.\
  ⚠️ Setting `maxEmails` does not guarantee the actor will always reach that number.

***

### FAQ

#### What does Facebook Email Scraper extract?

✅ Facebook Email Scraper extracts email addresses found in publicly available Facebook bios and posts that are related to the keywords you provide, and filters them by your `customDomains` (if set).

#### Do I need to provide keywords?

✅ Yes. `keywords` is required. The scraper uses your keyword list to guide what relevant Facebook content to focus on for email discovery.

#### Can I limit results to specific email providers?

✅ Yes. Use `customDomains` to target specific email domains such as `@gmail.com` for more focused results.

#### What happens if I set a very high `maxEmails`?

✅ The actor stops once `maxEmails` is reached, but setting it higher can increase scraping time and still does not guarantee reaching the exact limit. Large searches may take longer.

#### Which platform is supported?

✅ The only supported platform value in the input schema is `Facebook`.

#### Can I use proxies?

✅ Yes. You can provide `proxyConfiguration` to configure how requests are proxied. This helps the scraper stay more reliable during long or demanding runs.

#### Is there an API or coding requirement to use it?

✅ No coding is required to get results in Apify Console. You only provide the JSON input, run the actor, and then export the dataset.

#### Is it legal to use this for lead generation?

✅ This actor works with **publicly accessible sources** only, but whether your use case complies with laws and platform rules is your responsibility. Ensure your outreach practices follow applicable privacy and anti-spam requirements (including GDPR/CCPA where relevant).

***

### Support & feature requests

Want to improve your Facebook Email Scraper results? Share feedback and feature ideas—we use them to guide updates.

- 💡 **Feature Requests**: Examples include CSV export improvements, enhanced filtering options, and smoother CRM integrations based on your workflows.
- 📧 **Contact**: For custom solutions or feature requests, reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for the Facebook email scraper experience.

***

*If you’re searching for the most comprehensive and SEO-optimized Facebook Email Scraper, this is built to help you collect targeted Facebook emails faster—at scale.*

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords to search for.

## `location` (type: `string`):

Location to filter search results.

## `platform` (type: `string`):

Select platform.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

## `proxyConfiguration` (type: `object`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "platform": "Facebook",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy"
}
```

# 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 = {
    "keywords": [
        "founder",
        "marketing"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/facebook-email-scraper").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 = {
    "keywords": [
        "founder",
        "marketing",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/facebook-email-scraper").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 '{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call solid-scraper/facebook-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Email Scraper",
        "description": "📧 Facebook Email Scraper extracts verified emails from public profiles and pages—fast and targeted. Ideal for sales, marketers, and agencies seeking high-quality leads. 🚀 Enhance outreach with cleaner data and smarter prospecting.",
        "version": "0.0",
        "x-build-id": "3njz9y2B9m8txai7i"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~facebook-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-facebook-email-scraper",
                "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~facebook-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-facebook-email-scraper",
                "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~facebook-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-facebook-email-scraper",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "A list of keywords to search for.",
                        "default": [
                            "founder",
                            "marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Facebook"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Facebook"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
