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

📧 Facebook Email Scraper finds business emails from Facebook profiles & pages—fast, accurate, and easy to use. 🚀 Perfect for lead generation, B2B outreach, and market research. Save time and grow your pipeline!

- **URL**: https://apify.com/scraperoka/facebook-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Social media, Other
- **Stats:** 2 total users, 1 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

### Facebook Email Scraper 🎯

Manually visiting hundreds of Facebook profiles to collect emails wastes hours you don’t have. **Facebook Email Scraper** automates email extraction from publicly available Facebook bios and posts using your keywords and email-domain filters. This Facebook email scraper tool is ideal for marketers, recruiters, and growth teams looking for bulk Facebook email extraction (without the busywork) — thousands of records in minutes.

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "network": "Facebook.com",
  "keyword": "marketing",
  "title": "Marketing & Growth Lead",
  "description": "We help brands scale. DM for partnerships. Reach us at hello@gmail.com",
  "url": "https://example.com/profile/marketing-lead",
  "email": "hello@gmail.com",
  "proxyGroups": ["some-proxy-config"]
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network is recorded as `Facebook.com` |
| `keyword` | string | Which keyword produced this email hit (useful for reporting and iteration) |
| `title` | string | The title text from the discovered result that led to the email |
| `description` | string | The surrounding text where the email was found (great for context) |
| `url` | string | The source URL tied to the email so you can review provenance |
| `email` | string | The extracted email address that matches your domain filters |
| `proxyGroups` | array | The proxy configuration used for the run (useful for reproducibility) |
| `status` | not provided | Note: the actor pushes the fields above; there is no `status` field in the output row schema shown |

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

### Why Facebook Email Scraper?

There are a lot of ways to pull contact data from Facebook — here’s what sets Facebook Email Scraper apart.

#### Keyword and email-domain targeting

You provide `keywords` and `customDomains`, so the scraper focuses on relevant signals and extracts only emails that match your preferred domains (for example, `@gmail.com`). This makes a big difference when you’re doing a Facebook lead email scraper workflow and need higher relevance.

#### Outputs contact hits as structured records

Each found email is pushed as a structured JSON row containing `keyword`, `title`, `description`, `url`, and `email`. That means you can immediately use the data in your lead lists, CRM imports, or analyst pipelines as a Facebook contact email extractor output.

#### Built for long runs with resilience

The actor includes retries and stop conditions designed to keep runs efficient when results are sparse or access is limited. If you’re doing bulk Facebook email extraction, this helps prevent wasting time on low-yield iterations.

#### Works with Apify proxy support

You can configure `proxyConfiguration` to improve scraping reliability, especially for larger searches. This makes Facebook group email scraper and Facebook page email scraping-style projects more dependable in practice.

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of terms used to find relevant Facebook bios and posts where emails may appear |
| `location` | ⬜ | Filters results by a specific location (leave empty for broader coverage) |
| `platform` | ⬜ | Selects the platform to scrape (currently only `Facebook`) |
| `customDomains` | ⬜ | Limits extracted emails to the email domains you specify (for example `@gmail.com`) |
| `maxEmails` | ⬜ | Caps how many unique emails the scraper collects before stopping |
| `engine` | ⬜ | Selects the scraping engine (`legacy` is available in the schema) |
| `proxyConfiguration` | ⬜ | Sets up proxy settings for the run (recommended for better reliability on larger jobs) |
| ↳ `proxy support` | ⬜ | Uses Apify Proxy routing when provided in your proxy configuration |
| ↳ other proxy fields | ⬜ | Any additional proxy configuration supported by Apify’s proxy editor |

### Core Capabilities

#### Keyword-driven email harvesting

Facebook Email Scraper uses your `keywords` to target relevant publicly available Facebook bios and posts, then extracts emails associated with the matched content. This is what makes it useful for search-based workflows like scrape Facebook page emails and Facebook ads lead email scraper-style lead discovery.

#### Domain-filtered results for cleaner leads

With `customDomains`, you can constrain results to the email providers you care about (such as `@gmail.com`). That keeps your output focused and makes downstream enrichment easier when you’re building a Facebook contact email extractor dataset.

#### Pagination with stop conditions

The actor processes results across pages while watching for `maxEmails` and stopping when additional pages are no longer productive. This supports practical “find as much as possible, but don’t run forever” behavior during automated Facebook email harvesting.

#### Deduplication to avoid repeated emails

It tracks already seen emails and avoids pushing duplicates into your dataset. That helps your bulk Facebook email extraction runs stay tidy for reporting and CRM ingestion.

#### Resilient execution with retries

When runs hit sparse results or access issues, the actor applies retry logic and decides when to stop a keyword/domain combination. This helps reduce wasted compute time while maintaining momentum for Facebook public email scraper tasks.

#### Real-time dataset writing

As emails are found, the actor pushes a record immediately to the dataset (`Actor.push_data` with `charged_event_name="result"`). You don’t have to wait for the entire run to finish to review progress.

### Who Gets the Most Out of This

Here’s how different teams put Facebook Email Scraper to work:

**Growth and Performance Marketers** — Use it to accelerate prospecting by pulling contact emails tied to specific marketing and founder-related keywords, then import directly into outreach workflows. The domain filters help keep lists relevant to your targeting strategy.

**Sales Development Representatives** — Run it to build lead lists faster from public Facebook bios and posts, then enrich your pipeline with emails that match your preferred domains. You spend more time contacting leads and less time hunting manually.

**Recruiters and Talent Sourcing Teams** — Use Facebook Email Scraper to find contact emails associated with people publishing public career- or role-related statements. It’s an efficient way to turn search inputs into a structured lead dataset for outreach.

**Researchers and Data Analysts** — Because every output includes fields like `keyword`, `title`, `description`, `url`, and `email`, you can analyze which keyword themes return the most email matches and track yields across runs.

**Automation & Integration Specialists** — Trigger the actor in an automated pipeline and feed results into downstream systems. The consistent row structure makes it easier to connect with webhooks, CRMs, and data stores for scheduled lead refreshes.

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

No coding needed. Here's how to run Facebook Email Scraper from start to finish:

1. **Open** the actor on Apify — log in and open the actor page via [console.apify.com](https://console.apify.com).
2. **Enter your inputs** — set `keywords` (required) and optionally `customDomains`, `location`, `maxEmails`, and `proxyConfiguration`.
3. **Configure proxy settings** — if you plan larger or repeated runs, enable the proxy option in `proxyConfiguration` for better reliability.
4. **Hit Run** — watch the live logs for progress while it searches for matching email contacts.
5. **View results** — open the dataset tab to see extracted emails as they’re pushed.
6. **Export your file** — download your dataset as JSON, CSV, or Excel from the dataset tab.

The whole process takes under 5 minutes to set up.

### Integrations & Export Options

Once your data is collected, Facebook Email Scraper plugs directly into your existing workflow.

You can download results from the Apify dataset tab in formats like **JSON, CSV, and Excel** for direct use in lead lists and reports. If you’re using a Facebook email extractor software workflow, this keeps your handoffs fast.

For automation and distribution, you can connect via Apify-native options, **Zapier / Make**, and **webhooks**, plus trigger runs programmatically via the **Apify API**. For deeper setup steps, refer to the Apify documentation at [apify.com/docs/api](https://apify.com/docs/api).

### Pricing & Free Trial

Facebook Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can start with several test runs using the free allowance, then scale as your needs grow.

After testing, you’ll typically pay for Apify platform compute on a pay-as-you-go basis (Apify pricing depends on your run configuration). For the exact current numbers, check the Apify pricing page on [apify.com](https://apify.com).

Start for free at [apify.com](https://apify.com) and scale when you're ready.

### Reliability & Performance

| What We Handle | How |
|---|---|
| Access variability | Includes retry logic and sensible stop conditions |
| Proxy-based reliability | Supports proxy configuration for more dependable runs |
| Duplicate prevention | Deduplicates emails using a “seen emails” set |
| Run efficiency | Stops when `maxEmails` is reached and avoids continuing when results are no longer productive |
| Ongoing results visibility | Writes results to the dataset as it finds them |

Limitations: the actor only works with **publicly available data** on Facebook. If emails are not present in publicly visible bios/posts, you should expect low or empty results for those specific keywords/domains. For enterprise-scale needs, contact us to discuss custom configurations.

### Frequently Asked Questions

#### Is there a free plan or trial for Facebook Email Scraper?

Yes. Apify provides a free tier so you can run a few tests before deciding whether to scale up. This is ideal for validating your keywords and `customDomains` first.

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

No. This actor is designed to work with publicly available Facebook content. You should not expect it to access login-gated or private information.

#### How accurate is the data extracted by Facebook Email Scraper?

Accuracy depends on what people publish publicly. Facebook Email Scraper extracts email addresses from publicly available bios and posts related to your `keywords`, and it filters by `customDomains` so you get results aligned with your domain targeting.

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

You control the upper bound using `maxEmails`. The scraper stops when that limit is reached, and higher limits can increase the potential number of collected emails but don’t guarantee you’ll reach the cap for every run.

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

Freshness depends on when you run the actor. Each run collects emails from the current publicly available content it can access at that time, so re-running periodically helps keep your lead list up to date.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor is built to work with **publicly available data**. You are responsible for ensuring your use complies with GDPR, CCPA, platform Terms of Service, and any applicable local regulations.

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

Yes. You can export your Apify dataset as JSON, CSV, or Excel directly from the Apify dashboard. If you want an automated sync, you can also connect via Apify integrations or automation tools.

#### Can I run this on a schedule automatically?

Yes. You can schedule runs using Apify’s scheduling capabilities. This is useful for repeat lead refresh cycles when you run Facebook messenger email scraper or ongoing Facebook public email scraper campaigns.

#### Can I access Facebook Email Scraper via API?

Yes. You can trigger the actor and retrieve results programmatically using the Apify API. This is a common approach for automated Facebook ads lead email scraper pipelines.

#### What happens if the actor hits an error?

The actor is designed with retries and stop conditions so runs can continue where possible. If it can’t retrieve useful data for a section of the process, it may stop based on its built-in logic rather than failing immediately.

### Need Help or Have a Request?

Got a question about Facebook Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help with setup questions and welcome ideas like batch CSV upload workflows and webhook on completion triggers.

### Disclaimer & Responsible Use

*Facebook Email Scraper is the fastest, most reliable way to build keyword-targeted email leads from Facebook — start your free run today.*

This actor collects **publicly available data**. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for compliance with GDPR, CCPA, platform Terms of Service, and any applicable local regulations when using or storing the results.

For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# 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("scraperoka/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("scraperoka/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 scraperoka/facebook-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperoka/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 finds business emails from Facebook profiles & pages—fast, accurate, and easy to use. 🚀 Perfect for lead generation, B2B outreach, and market research. Save time and grow your pipeline!",
        "version": "0.0",
        "x-build-id": "5zC9D0JIfbF0ls1XM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~facebook-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-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/scraperoka~facebook-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-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/scraperoka~facebook-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
