# Facebook Page Lead Scraper (`scrapapi/facebook-page-lead-scraper`) Actor

- **URL**: https://apify.com/scrapapi/facebook-page-lead-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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** Lead Scraper 📱

The **Facebook** Page Lead Scraper allows users to **extract** a variety of **data** from public **Facebook** pages and profiles. It streamlines the process of collecting lead addresses, ensuring accuracy and efficiency.

This tool is capable of gathering additional information such as page names, descriptions, and website links. It provides a comprehensive solution for those looking to **extract** valuable **contact** details and related **data** from **Facebook**.

By automating the **data** **extract**ion process, it eliminates the need for manual effort and reduces the risk of errors. Users can rely on this tool to gather information that supports marketing campaigns, lead generation, and research initiatives.

Facebook Page Lead Scraper is a powerful tool designed to help users extract lead addresses from Facebook pages efficiently and accurately. It simplifies the process of gathering contact information for marketing, research, or outreach purposes.

Using an lead extractor for Facebook pages can save countless hours compared to manual data collection. This tool automates the process, ensuring you capture the necessary information without hassle.

With the Facebook lead scraping tool, you can gather valuable contact details from public Facebook profiles and pages. It is ideal for businesses, marketers, and researchers looking to expand their outreach.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead Addresses | Extract lead addresses listed on public Facebook pages or profiles. |
| Page Name | Retrieve the name of the Facebook page or profile. |
| Page Description | Capture the description or bio of the Facebook page. |
| Website Links | Extract website URLs linked to the Facebook page or profile. |
| Contact Information | Gather other publicly available contact details like phone numbers. |
| Page Category | Identify the category or type of the Facebook page. |
| Number of Followers | Retrieve the follower count of the Facebook page. |
| Social Media Links | Extract links to other social media profiles shared on the page. |

### Key Features of **Facebook** Lead Scraper

Here are the **standout features** that make the **Facebook** Lead Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ Efficiently extracts lead addresses from public **Facebook** pages and profiles
- ⭐ Supports additional data extraction such as page names descriptions and website links
- ⭐ User-friendly interface designed for both beginners and professionals
- ⭐ Ensures compliance with data protection and privacy regulations
- ⭐ Automates the data extraction process to save time and reduce manual effort
- ⭐ Provides accurate and reliable results with minimal errors
- ⭐ Offers customizable settings for targeted data scraping
- ⭐ Compatible with a wide range of **Facebook** pages and profiles
- ⭐ **Regular** updates to maintain compatibility with **Facebook**s platform changes
- ⭐ **Secure** and confidential data handling to protect user privacy
- ⭐ Includes detailed documentation and customer support for ease of use
- ⭐ Scalable solution suitable for small businesses and large enterprises

### How to use **Facebook** Lead Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Facebook** leads today:

1. ✅ Log in to the **Facebook** Page Lead Scraper tool using your credentials
2. ✅ Enter the URL of the **Facebook** page or profile you want to scrape
3. ✅ **Select** the data fields you wish to extract such as lead addresses or page descriptions
4. ✅ Adjust the scraping settings to customize the data extraction process
5. ✅ **Start** the scraping process and wait for the tool to gather the data
6. ✅ **Review** the extracted data displayed in the tools interface
7. ✅ **Export** the collected data to your preferred format such as CSV or Excel
8. ✅ Verify the extracted information to ensure accuracy and completeness
9. ✅ Repeat the process for additional **Facebook** pages or profiles as needed
10. ✅ Utilize the data for your marketing research or outreach activities
11. ✅ Refer to the documentation for troubleshooting or advanced settings
12. ✅ Contact customer support if you encounter any issues or need assistance

### Use Cases 🎯

Lead Generation
🎯 Extract lead addresses from **Facebook** pages to build a list of potential leads
🎯 **Identify** businesses or individuals interested in your products or services

Market Research
🎯 Gather data from **Facebook** pages to analyze market trends and consumer behavior
🎯 **Identify** competitors and understand their online presence

Networking Opportunities
🎯 **Find** contact information for professionals or organizations in your industry
🎯 Expand your network by reaching out to relevant **Facebook** page owners

Content Promotion
🎯 **Use** extracted lead addresses to share your content with a targeted audience
🎯 Promote events products or services directly to interested parties

Data Analysis
🎯 **Analyze** the collected data to gain insights into specific industries or demographics
🎯 Utilize the information to improve your business strategies

### Why choose us? 💎

Our **Facebook** Page Lead Scraper is designed with efficiency and reliability in mind. It simplifies the process of extracting lead addresses and other data from **Facebook** pages, saving users time and effort.

This tool is equipped with **advanced** features to ensure accurate and comprehensive data collection. We prioritize user privacy and compliance with data protection regulations, providing a secure and trustworthy solution.

Our tool is **regular**ly updated to stay compatible with **Facebook**'s platform, ensuring uninterrupted service. Whether you are a small business owner or a large enterprise, our scraper is **scalable** to meet your needs.

With a **user-friendly** interface and detailed documentation, you can start extracting data with ease. Our dedicated customer support team is always available to assist you with any questions or issues.

Choose our **Facebook** Page Lead Scraper for a **reliable** and efficient data extraction experience.

### **Facebook** Lead Scraper Scalability 📈

The **Facebook** Page Lead Scraper is built to handle data extraction tasks of any size. Whether you need to scrape a single **Facebook** page or thousands, our tool is designed to scale **seamless**ly.

Its robust architecture ensures consistent performance even when processing large volumes of data. This makes it an ideal solution for both small businesses and large enterprises.

The tool's **customizable** settings allow users to tailor the scraping process to their specific needs. With its ability to handle multiple tasks simultaneously, the scraper maximizes efficiency and minimizes downtime.

Our team continuously updates the tool to ensure it can handle the latest changes to **Facebook**'s platform. This ensures that your data extraction needs are met, regardless of scale or complexity.

### **Facebook** Lead Scraper Legal Guidelines ⚖️

**Yes**—scraping **Facebook** is **legal** as long as you follow **ethical** and **compliant** practices. The **Facebook** Lead Scraper extracts only **publicly available** information from **public** **Facebook** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Only** scrape data from public **Facebook** pages or profiles with visible contact information
⚖️ **Ensure** compliance with **Facebook**s terms of service and policies when using the tool
⚖️ **Do not** use the extracted data for illegal or unethical purposes
⚖️ **Obtain** consent from individuals before using their contact information for marketing purposes
⚖️ **Avoid** scraping sensitive or private information from **Facebook** profiles
⚖️ **Use** the tool responsibly and respect the privacy of **Facebook** users
⚖️ **Adhere** to local and international data protection regulations such as GDPR or CCPA
⚖️ Regularly review updates to **Facebook**s policies to ensure continued compliance

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Facebook Page Lead Scraper"],
  "country": "Global",
  "maxLeadNumbers": 20,
  "platform": "Facebook",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxLeadNumbers | Maximum leads to collect (default 20) |
| platform | Platform to scrape (Facebook) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Facebook",
    "keyword": "Facebook Page Lead Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "lead": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Facebook as the source |
| keyword | Keyword that triggered the result (Facebook Page Lead Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Facebook profile link |
| lead | Extracted lead address |

### FAQ ❓

#### What is the Facebook Page **Lead Scraper**?

The Facebook Page Lead Scraper is a tool that extracts lead addresses and other data from public Facebook pages and profiles.

#### Is the Facebook Page **Lead Scraper** **legal** to use?

**Yes**, as long as you scrape data from public pages and comply with Facebook's terms of service and data protection laws.

#### What data can I **extract** using this tool?

You can extract lead addresses, page names, descriptions, website links, contact information, and more.

#### Can I scrape **private** Facebook profiles?

**No**, the tool only works with public Facebook pages and profiles to ensure **compliance** with privacy regulations.

#### Is the tool user-friendly?

**Yes**, the Facebook Page Lead Scraper is designed with a simple and intuitive interface for ease of use.

#### How do I **export** the **extract**ed data?

You can export the data in formats like **CSV** or Excel directly from the tool.

#### Is **customer support** available?

**Yes**, our **dedicated support** team is available to assist with any questions or issues.

#### Can I use the tool for **lead generation**?

**Yes**, the tool is ideal for extracting lead addresses and building a list of potential leads.

#### Does the tool comply with GDPR and other regulations?

**Yes**, the Facebook Page Lead Scraper is designed to comply with GDPR, CCPA, and other data protection laws.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with Facebook's platform and to improve functionality.

#### Can I scrape multiple Facebook pages at once?

**Yes**, the tool supports simultaneous scraping of multiple Facebook pages.

#### What are the system requirements for using the tool?

The tool is web-based and requires a stable internet connection and a modern web browser.

#### Is there a **limit** to the number of pages I can scrape?

The tool is scalable and can handle a large number of pages depending on your subscription plan.

#### Can I customize the data **extract**ion process?

**Yes**, the tool offers customizable settings to tailor the scraping process to your needs.

#### Is the tool **secure**?

**Yes**, the Facebook Page Lead Scraper ensures **secure** and confidential data handling.

# Actor input Schema

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

List of keywords to search for on Facebook (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Facebook profiles/posts containing these keywords and extract email addresses.

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

Select platform.

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

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

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

Maximum number of emails to collect per keyword (default: 20).

## `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`):

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

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

# 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": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapapi/facebook-page-lead-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": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapapi/facebook-page-lead-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": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapapi/facebook-page-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Page Lead Scraper",
        "version": "0.1",
        "x-build-id": "quuqPEq6ELaZXJWEg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~facebook-page-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-facebook-page-lead-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/scrapapi~facebook-page-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-facebook-page-lead-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/scrapapi~facebook-page-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-facebook-page-lead-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": "List of keywords to search for on Facebook (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Facebook profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Facebook"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Facebook"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "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": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```