# Facebook Email Scraper (Fast Advanced And Cheapest) (`scrapeflux/fast-facebook-email-scraper`) Actor

🚀 Facebook Email Scraper Fast Advanced — extract emails and contacts quickly with advanced filtering, high accuracy, and budget-friendly pricing. 📩 Perfect for lead generation, marketing outreach, and B2B sales. ⚡ Reliable & efficient.

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

## Pricing

from $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Facebook Email Scraper - Fast, Advanced and Cheapest ⚡

Finding emails from Facebook leads is slow when you do it manually—and it quickly turns outreach into guesswork. **Facebook Email Scraper - Fast, Advanced and Cheapest** helps you extract email addresses from Facebook using keywords, optional location targeting, and email-domain filters. If you’re searching for a facebook email scraper, facebook lead scraper, or facebook email finder tool, this is built for you. Marketing teams, sales prospecting teams, and researchers use it to build targeted email lists from public web data. In one run, you can collect up to your chosen `maxEmails` limit (with sensible stopping rules) and see results appear in the dataset as they’re found.

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
{
  "network": "Facebook.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "No URL",
  "email": "john@gmail.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network for the record (useful for reporting and joins across datasets). |
| `keyword` | string | The keyword that led to this finding—helps you understand which themes produce results. |
| `title` | string | A short result title captured alongside the email so you can quickly sanity-check relevance. |
| `description` | string | The extracted text context around the email, handy for review and downstream filtering. |
| `url` | string | The source link for the record—useful for verification and audit trails. |
| `email` | string | The extracted contact email address you can use for outreach workflows. |

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

***

### Setting It Up

Drop this into your `input.json` and you're ready to go:

```json
{
  "keywords": ["manager", "founder"],
  "location": "New York, USA",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 50
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | Provide the keywords (or queries) you want the actor to use when looking for relevant Facebook contact signals. |
| `location` | ⬜ | Optionally filters results by a location string you provide. |
| `customDomains` | ⬜ | Limits extracted emails to the domains you specify (for example `@gmail.com`, `@yahoo.com`). |
| `maxEmails` | ⬜ | Sets a maximum number of emails to collect before the actor stops, helping you control runtime and cost. |

***

### What It Does

Facebook Email Scraper - Fast, Advanced and Cheapest extracts email addresses from Facebook based on your chosen `keywords`, optional `location`, and `customDomains`.

#### Extract at Scale with Keyword and Domain Filters

You drive the search direction using `keywords`, and you control the types of emails you want by limiting `customDomains` (for example, gmail or yahoo domains). This makes the facebook contact email extractor workflow more targeted for lead generation and list building.

#### Faster, Practical Runs with a Built-In Cap

You can set `maxEmails` to stop once enough emails have been collected. If you’re running bulk facebook email scraper tasks, this gives you predictable stopping behavior instead of “scrape forever” runs.

#### Clean, Dataset-Ready Records

Each found email is pushed as a structured object containing `keyword`, `title`, `description`, `url`, and `email`. That makes it straightforward to filter, deduplicate, and import into your CRM—one of the core reasons teams use facebook email scraping software.

#### Progressive Output While It Works

As the actor finds results, it pushes them into the dataset incrementally. You don’t have to wait for the entire run to finish to start reviewing what’s working.

#### Resilient Execution with Resume Support

If a run is interrupted, the actor saves and resumes progress so you can continue without starting from scratch. This helps keep large facebook email list builder projects on track even when runs span longer periods.

Overall, this facebook email scraper turns public Facebook contact signals into an exportable dataset of emails—fast, advanced, and built to be cost-aware.

***

### Why Facebook Email Scraper - Fast, Advanced and Cheapest?

There are plenty of ways to pull data from Facebook—here’s why Facebook Email Scraper - Fast, Advanced and Cheapest stands out.

#### Targeted Email Quality with Domain Controls

Instead of collecting every possible email-looking string, you specify `customDomains` so output is more aligned with the kinds of contacts you want. This approach is especially useful for a targeted facebook email scraper when you’re building a B2B or consumer outreach list.

#### Built for Speed and Controlled Run Size

The actor can stop once it reaches your `maxEmails` target, so you can iterate quickly with different keywords and email-domain filters. That’s a big win for fast facebook email scraper workflows where you need feedback early.

#### Runs Reliably with Progress Tracking

It maintains progress so you can resume rather than lose work. This resilience matters when you’re doing advanced facebook email scraper runs with multiple keyword and domain combinations.

***

### Real-World Use Cases

Here's how different teams put Facebook Email Scraper - Fast, Advanced and Cheapest to work:

**Sales Teams**\
A sales manager needs fresh outreach targets for a specific niche. They run the actor with keywords like “manager” and “founder,” restrict emails to specific domains with `customDomains`, and set `maxEmails` to get a workable list quickly. Within the same run, they start importing results into their CRM and prioritizing leads by the `keyword` that generated them.

**Marketing Agencies**\
An agency is building multiple campaign lists and wants consistent data structure across clients. They tailor `keywords` per campaign and optionally set `location` to focus on regional prospects. The exported dataset makes it easy to map `url` and `description` into internal review steps before outreach.

**Freelance Researchers**\
A researcher needs contact datasets for a study but wants a repeatable workflow. They run bulk searches with selected keywords and domain filters, exporting the results as JSON or CSV for analysis. Having `title`, `description`, and `url` included makes it easier to validate findings and document sources.

**Developer / Automation Specialists**\
An automation engineer wants an API-driven pipeline that refreshes leads on a schedule. They trigger the actor with the same input schema every time, then pull the dataset from Apify and push it into their downstream systems. The consistent output fields (`email`, `url`, `keyword`) simplify integration and reduce mapping work.

**Recruiting and Talent Sourcing**\
A talent sourcer searches for people using role-based keywords and needs emails for outreach. They constrain domains to match preferred contact channels and cap `maxEmails` so trials are quick. The result is a cleaner email list builder process that speeds up follow-ups.

***

### How to Run It

No code required. Here's how to get your first results in under 5 minutes:

1. **Open the actor on Apify** — go to the actor page on [console.apify.com](https://console.apify.com) and find **Facebook Email Scraper - Fast, Advanced and Cheapest**.
2. **Enter your inputs** — set `keywords` (required), and optionally add `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings (if needed)** — set your proxy preference using Apify’s built-in options for reliable scraping.
4. **Start the run and watch the live log** — keep an eye on progress and watch emails appear as they’re pushed.
5. **Open the Dataset tab** — view records immediately, including `keyword`, `url`, and `email`.
6. **Export in your preferred format** — download JSON, CSV, or Excel from the Apify dataset.
7. **Refine and re-run** — adjust `keywords`, widen or narrow `customDomains`, and change `maxEmails` to improve results.

The whole setup takes under 5 minutes — results start appearing within seconds of launch.

***

### Export & Integration Options

Once your data is collected, Facebook Email Scraper - Fast, Advanced and Cheapest fits directly into your existing workflow.

Export formats are available from the Apify dataset tab, including JSON, CSV, and Excel. This makes it easy to move from scraping to analysis, segmentation, and outreach list building.

For automation, you can integrate using Apify’s API access, run it on a schedule, and connect downstream steps using tools like Zapier or Make and webhook-based flows. For details on how to do this in your environment, check the Apify documentation.

***

### Pricing

Facebook Email Scraper - Fast, Advanced and Cheapest runs on Apify, which includes a **free tier** — no credit card needed to start.

You get an initial amount of free platform credits on sign-up, enough for several real test runs. For larger workloads, you scale using Apify’s pay-as-you-go model billed per Actor compute unit (CU) rather than a fixed subscription lock-in. For the exact current pricing and plan details, refer to the Apify pricing page.

Start free at [apify.com](https://apify.com) — scale up when you need to.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Progress recovery | The actor saves progress so you can resume instead of restarting from zero. |
| Result caps | `maxEmails` stops the run once enough emails are collected. |
| Targeted filtering | Use `customDomains` and `keywords` to focus results and reduce noise. |
| Incremental dataset writes | Records are pushed as they’re found, so partial results are still captured. |

Limitations: the actor extracts emails from publicly available sources. Results depend on what contact information is present in the public data for the pages it encounters, and you may need to broaden `keywords` or expand `customDomains` to increase coverage. Login-gated or private content is not in scope.

For enterprise-scale needs or custom configurations, reach out and we’ll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes—Apify provides a free tier for this actor. You can use it for smaller test runs, and heavier workloads typically require a paid plan.

#### Do I need to log in or create an account on Facebook?

No. This actor extracts email addresses from publicly available sources based on your inputs, so you don’t need a Facebook login.

#### How accurate is the extracted data?

The output accuracy depends on what email addresses are present in the publicly available data it processes. It extracts emails using pattern matching, so using better `keywords` and targeted `customDomains` generally improves relevance.

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

You control results using `maxEmails`. The actor will stop once it reaches your requested maximum (or when it decides there are no more new results to find).

#### How fresh is the data?

Freshness depends on what exists in the publicly available data at the time of your run. If you re-run the actor later with updated inputs, you’ll get a new snapshot.

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

You should use the actor only with a compliance-first workflow. It targets publicly available data, but you’re responsible for how you store, process, and use it in line with GDPR, CCPA, and applicable platform rules.

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

Yes. You can export the dataset from the Apify dashboard as JSON, CSV, or Excel, then import it into Google Sheets or other tools. You can also connect via automation workflows depending on your stack.

#### Can I schedule this to run automatically?

Yes. You can schedule Apify actors to run automatically on a schedule using Apify’s scheduling capabilities.

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

Yes. You can access results programmatically through Apify API tooling, depending on how you trigger and manage your runs.

#### What happens when the actor encounters an error?

When errors happen, the actor continues its overall process while relying on progress tracking to avoid losing work. If results can’t be found within the run logic, you may receive fewer emails than requested.

***

### Get Help & Use Responsibly

Got a question about Facebook Email Scraper - Fast, Advanced and Cheapest or a feature you’d like added? Reach out at <dataforleads@gmail.com>—we actively maintain this actor and can help with practical configuration tips like better keyword/domain targeting for facebook email finder tool results. If you want improvements, ideas like expanding input options or adding custom filters are welcome.

***

**This actor collects only publicly available data.** It does not access private accounts, login-gated pages, or password-protected content. You are responsible for complying with GDPR, CCPA, and applicable platform Terms of Service when using and storing 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 or queries to search for.

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

Location to filter search results.

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

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# 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": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeflux/fast-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": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Email Scraper (Fast Advanced And Cheapest)",
        "description": "🚀 Facebook Email Scraper Fast Advanced — extract emails and contacts quickly with advanced filtering, high accuracy, and budget-friendly pricing. 📩 Perfect for lead generation, marketing outreach, and B2B sales. ⚡ Reliable & efficient.",
        "version": "1.0",
        "x-build-id": "Ypt0L0WRSwZ4z1c8a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeflux~fast-facebook-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeflux-fast-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/scrapeflux~fast-facebook-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeflux-fast-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/scrapeflux~fast-facebook-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeflux-fast-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 or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter 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
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
