# Facebook Email Scraper Fast Advanced And Cheapest (`scraperoka/facebook-email-scraper-fast-advanced-and-cheapest`) Actor

🚀 Facebook Email Scraper Fast Advanced & Cheapest! Extract verified emails from Facebook profiles/pages in minutes with advanced filters, clean results & easy setup. ✅ Perfect for B2B leads, outreach & marketing campaigns. 📩 Get more contacts—less cost.

- **URL**: https://apify.com/scraperoka/facebook-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (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 $2.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 🎯
Manually visiting Facebook pages to collect email addresses wastes hours you don’t have. **Facebook Email Scraper - Fast, Advanced and Cheapest** finds emails from Facebook using your keywords and email-domain filters, so marketers, recruiters, and growth teams can build outreach lists quickly. This Facebook email scraper delivers **Facebook email extraction tool** results with better targeting—ideal for marketers, recruiters, and growth teams trying to scale lead generation. You can collect thousands of records in a single run, depending on your inputs and limits.

---

### What You Get: Sample Output
Here's a sample record from a single run:

```json
{
  "network": "Facebook.com",
  "keyword": "manager",
  "title": "Example Facebook Page Title",
  "description": "Example description text containing an email contact.",
  "url": "https://www.facebook.com/examplepage",
  "email": "alex.manager@gmail.com"
}
````

**Output Fields (Dataset)**
| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | The source network for the contact (always `Facebook.com`) |
| `keyword` | string | The keyword that led to this email result, helping you track which searches work |
| `title` | string | The title associated with the result, useful for quick relevance checks |
| `description` | string | The surrounding extracted text where the email was detected (good for context) |
| `url` | string | The link to the Facebook page/profile result for validation and follow-up |
| `email` | string | The extracted email address you can use for outreach |

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

***

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

There are a lot of ways to pull contact data from Facebook — here’s what sets **Facebook Email Scraper - Fast, Advanced and Cheapest** apart.

#### Fast bulk extraction with controllable limits

You can cap how many emails to collect using `maxEmails`, which helps you control scraping time and cost while still targeting enough leads for testing.

#### Input flexibility for better targeting

Use `keywords` to drive results, optionally narrow by `location`, and use `customDomains` (like `@gmail.com`) to focus on the email formats that matter most for your outreach strategy—ideal for a **facebook leads email scraper** workflow.

#### Resumable runs for reliability

If a run stops, it saves progress (including already seen emails) so you can resume instead of starting over—useful for **bulk facebook email scraper** jobs and long searches.

#### Deduplicated email collection

The actor keeps a `seen_emails` set during the run, preventing the same email from being pushed repeatedly, so your results stay clean for downstream analysis and CRM import.

***

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords or queries to search for emails on Facebook |
| `location` | ⬜ | Location filter to narrow results (leave empty for no location targeting) |
| `customDomains` | ⬜ | List of custom email domains (examples include `@gmail.com` and `@yahoo.com`) so the scraper focuses on emails you want |
| `maxEmails` | ⬜ | Maximum number of emails to collect; the run stops once this limit is reached (helps control cost and runtime) |

***

### Core Capabilities

#### Keyword and domain driven email discovery

Use `keywords` to guide what kinds of Facebook pages/profiles to look for, and use `customDomains` to filter for the email extensions you care about. This is especially helpful when you’re building an **advanced facebook email finder** workflow with predictable lead formats.

#### Email-domain filtering for cleaner outreach lists

By selecting specific domains in `customDomains` (for example `@gmail.com`), the actor extracts matching email addresses and avoids irrelevant formats. This makes it easier to build a usable **facebook email list builder** without heavy post-processing.

#### Resilient execution with saved progress

The actor stores and loads progress so it can resume where it left off, including previously found emails. This supports long runs and makes the **fast facebook email scraper** experience more dependable.

#### Incremental dataset writing

Each extracted result is pushed to the Apify dataset as it’s found, so you can start exporting and analyzing without waiting for the entire run to finish.

#### Controlled results with `maxEmails`

If you’re testing outreach, running experiments, or managing budgets, `maxEmails` helps you cap the number of collected emails. Higher limits can take longer and don’t guarantee reaching the target, but they give you control over throughput.

***

### Who Gets the Most Out of This

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

**Growth and Lead Generation Teams** use targeted `keywords` plus `customDomains` to quickly build a structured outreach list. You end up with emails connected to the Facebook result `url`, making it easier to qualify prospects during outreach.

**Recruiters and Talent Sourcers** run focused searches by role-related keywords and (optionally) `location` to gather contact emails faster than manual browsing. The resulting dataset helps you assemble candidate outreach pipelines with less manual work.

**Sales Development Reps** benefit from email-domain filtering to standardize lead lists for sequences. You can set `maxEmails` to collect exactly what you need for an outreach sprint, then iterate on keywords when response rates come in.

**Digital Marketers and Campaign Managers** use keyword testing (multiple `keywords` runs) to identify which search terms produce the most relevant emails. This helps you improve **facebook email harvesting software** performance over time by learning what works.

**Automation & Data Engineering Specialists** can treat the dataset as a repeatable data source for downstream systems. The actor outputs structured records (`keyword`, `title`, `url`, `email`) that are easy to map into analytics pipelines or CRM ingestion workflows.

***

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

No coding needed. Here's how to run **Facebook Email Scraper - Fast, Advanced and Cheapest** from start to finish:

1. **Open the actor on Apify** — visit 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 `location`, `customDomains`, and `maxEmails` in the input form.
3. **Configure proxy settings** — use your preferred proxy setup from the Apify run options to improve scraping reliability.
4. **Hit Run and watch the live log** — monitor progress as results are found and pushed.
5. **View results in the dataset tab** — your extracted contacts appear incrementally in the default dataset view (“Scraped Leads”).
6. **Export as JSON, CSV, or Excel** — download directly from the Apify dashboard for analysis or import.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

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

You can export your results from the Apify dataset tab in **JSON**, **CSV**, or **Excel** formats. From there, it’s straightforward to load into CRMs, spreadsheets, and BI tools.

For automation, you can use Apify’s **API access** (via the Apify API) and trigger downstream actions with **webhooks** so your lead pipeline updates automatically when a run completes. No-code tools like **Zapier** or **Make** can also move your exported data into other systems, and you can run the actor automatically on a scheduled basis using Apify scheduling features.

***

### Pricing & Free Trial

**Facebook Email Scraper - Fast, Advanced and Cheapest** runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

You can run quick tests with the free allowance and then scale using Apify’s pay-as-you-go model. Costs are driven by Apify platform usage (compute units) rather than a per-email “row fee,” so you can run experiments safely and ramp up when your keyword/domain filters are working well. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Resuming after interruptions | Progress (including already seen emails) is saved and can be continued in later runs |
| Duplicate emails in output | The actor tracks `seen_emails` during the run to avoid re-pushing the same email |
| Result caps for budget control | `maxEmails` stops the run once your target is reached |
| Output availability during the run | Results are pushed incrementally into the dataset as they’re found |

**Limitations:** This actor extracts emails from **publicly available sources** that match your keyword/domain filters. If emails are not present in the public content being searched, you may receive fewer results than your `maxEmails` target.

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

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes—Apify offers a free tier for testing runs. If you’re collecting small batches for validation, you can usually get meaningful results without committing to paid usage first.

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

No. This actor extracts emails from **publicly available data** that can be viewed without authentication.

#### How accurate is the data?

Accuracy depends on what’s publicly present in the source content. The actor extracts email addresses and includes context via fields like `title`, `description`, and `url` so you can quickly verify relevance.

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

You control the number of results using `maxEmails`. The run stops when the limit is reached, and it may stop early if results become sparse or no new emails are found.

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

The freshness is based on when you run the actor. Each run captures the current publicly available content that matches your inputs at that time.

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

You should use it in compliance with applicable privacy laws and platform rules. The actor works with **publicly available data**, but it’s your responsibility to ensure your use, storage, and outreach practices follow GDPR/CCPA and other relevant regulations.

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

Yes. You can export the dataset from the Apify dashboard as **CSV** or **Excel**, and you can connect it to tools like Google Sheets via your normal import workflow.

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

Yes. Since it runs as an Apify actor, you can schedule it to run automatically on a recurring basis using Apify scheduling features.

#### Can I access this via API?

Yes. You can use the Apify API to trigger runs and retrieve results programmatically.

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

If errors happen during execution, Apify will reflect the run status in the run logs, and partial progress is preserved thanks to saved state. You can resume later to continue collecting remaining results.

***

### Need Help or Have a Request?

Got a question about **Facebook Email Scraper - Fast, Advanced and Cheapest** or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like “webhook on completion” and enhancements to improve bulk lead list workflows.

***

### Disclaimer & Responsible Use

*Facebook Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to build a targeted Facebook email list — start your free run today.*

You must use **publicly available data** only. This actor does not access private accounts, login-gated content, or password-protected pages. It’s your responsibility to comply with GDPR, CCPA, and any applicable platform Terms of Service. 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("scraperoka/facebook-email-scraper-fast-advanced-and-cheapest").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("scraperoka/facebook-email-scraper-fast-advanced-and-cheapest").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 scraperoka/facebook-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperoka/facebook-email-scraper-fast-advanced-and-cheapest",
                "--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 & Cheapest! Extract verified emails from Facebook profiles/pages in minutes with advanced filters, clean results & easy setup. ✅ Perfect for B2B leads, outreach & marketing campaigns. 📩 Get more contacts—less cost.",
        "version": "1.0",
        "x-build-id": "nb6jbwneH0gv50krG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~facebook-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-facebook-email-scraper-fast-advanced-and-cheapest",
                "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-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-facebook-email-scraper-fast-advanced-and-cheapest",
                "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-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-facebook-email-scraper-fast-advanced-and-cheapest",
                "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
