# Facebook Page Contact Info Scraper (`scraperoka/facebook-page-contact-info-scraper`) Actor

📇 Facebook Page Contact Info Scraper extracts phone, email, website, and other public contact details from Facebook pages. 🚀 Perfect for lead generation, sales outreach, and market research—fast, accurate, and easy to use. 💼

- **URL**: https://apify.com/scraperoka/facebook-page-contact-info-scraper.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 $0.01 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Facebook Page Contact Info & Email Scraper 🎯

Manually visiting dozens of Facebook pages to collect emails, phone numbers, and addresses wastes hours you don’t have. **Facebook Page Contact Info & Email Scraper** extracts Facebook page contact info and emails from publicly available page data in bulk. This Facebook page email scraper helps marketers, recruiters, and growth teams find relevant contacts faster—often across thousands of pages in a single run.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "url": "https://www.facebook.com/BlueSpringsSidingandWindows",
  "page_name": "BlueSprings Siding and Windows",
  "bio": "Serving Blue Springs & surrounding areas. Questions? Email us at sales@bluespringssiding.com or call 555-010-2044.",
  "emails_from_bio": ["sales@bluespringssiding.com"],
  "EMAIL": "sales@bluespringssiding.com",
  "PHONE": "555-010-2044",
  "MOBILE_PHONE": null,
  "ADDRESS": "123 Main St, Blue Springs, MO",
  "WEBSITE": "https://bluespringssiding.com",
  "DISPLAY_SUBTEXT": "Home Improvement",
  "scraped_at": "2026-06-03T11:42:18.321481",
  "success": true
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `page_name` | text | The Facebook page name the scraper could identify |
| `url` | text | The normalized Facebook Page URL used for this record |
| `bio` | text | The page’s bio/description text pulled from the main page |
| `emails_from_bio` | array | All email addresses detected in the page bio content |
| `EMAIL` | text | A single email value found in the page’s extracted contact fields (when available) |
| `PHONE` | text | The phone number captured from the page’s extracted contact fields |
| `MOBILE_PHONE` | text | The mobile phone value when present in the extracted contact fields |
| `ADDRESS` | text | The address value when present in the extracted contact fields |
| `WEBSITE` | text | The website value when present in the extracted contact fields |
| `DISPLAY_SUBTEXT` | text | The category/type label captured from the page’s extracted fields |
| `scraped_at` | date | When this record was captured by the actor |
| `success` | boolean | Whether the run produced usable results for that page |

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

***

### Why Facebook Page Contact Info & Email Scraper?

There are a lot of ways to pull data from Facebook pages — here’s what sets Facebook Page Contact Info & Email Scraper apart.

#### Built for contact extraction (not just browsing)

Facebook Page Contact Info & Email Scraper is specifically designed to scrape Facebook page contact info: bio/description plus structured contact fields like email, phone, address, and website when they’re publicly available. If you’re running a Facebook page email scraper workflow, the output is ready for lead lists and enrichment.

#### Resilient scraping with retries

The actor includes retry logic with backoff for failed requests, so you get better resilience on real-world page access. This helps when scraping Facebook page contact info at scale where occasional request hiccups happen.

#### Structured output written per page

Results are saved to your Apify dataset immediately as each page finishes. That means you can safely build lists progressively and reduce “all-or-nothing” risk when scraping Facebook page contact info extraction jobs.

#### Uses email-domain filtering from page content

Facebook Page Contact Info & Email Scraper focuses on extracting email addresses from publicly available sources on the pages you provide, including emails found in bio/description text. This is ideal when you’re searching for a Facebook about section email or trying to find email from Facebook page content.

***

### Configuring Your Run

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

```json
{
  "facebookPageUrls": [
    { "url": "https://www.facebook.com/humansofnewyork/" },
    { "url": "https://www.facebook.com/BlueSpringsSidingandWindows" }
  ]
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `facebookPageUrls` | ✅ | List of Facebook Page URLs to scrape for contact info. |
| ↳ `facebookPageUrls[].url` | ✅ | The Facebook Page URL you want to extract contact details from. |

***

### Core Capabilities

#### Bulk Facebook page processing

Provide `facebookPageUrls` with multiple Facebook page links and the actor processes each one, producing a structured contact record. This makes Facebook page URL to email scraper workflows straightforward when you need scale.

#### Email and bio extraction for lead building

The actor extracts bio/description text and returns any email addresses it finds in the bio as `emails_from_bio`. This supports use cases like email extraction from Facebook pages and scraping Facebook about section email content.

#### Structured contact fields from the About page

In addition to bio text, the actor also scrapes contact fields from each page’s About section and maps them into clearly named output fields (like `PHONE`, `EMAIL`, `ADDRESS`, and `WEBSITE` when present). This helps when you need a Facebook contact details finder that outputs usable values, not raw browsing output.

#### Built-in retries and resilience

When requests fail, the actor attempts retries to improve overall success rates across larger runs. It also uses live dataset writing so you retain results as they’re collected.

#### Dataset-first export (easy downstream use)

Because results are stored in an Apify dataset with consistent field names, you can export immediately as JSON, CSV, or Excel. This supports Facebook page contact info export CSV workflows and downstream CRM enrichment.

***

### Who Gets the Most Out of This

Here’s how different teams put Facebook Page Contact Info & Email Scraper to work:

**Lead generation marketers** — Use the actor to scrape Facebook page contact info and build outreach-ready lists with emails, phone numbers, and websites collected from page data. The result is faster list building for campaigns and better targeting for follow-ups.

**Sales Development Representatives** — Turn batches of target Facebook page URLs into structured contact records so you can move from prospect lists to first-touch emails quicker. This is especially helpful when you need a Facebook lead scraper email workflow that outputs fields your CRM can ingest.

**Recruiters and talent sourcers** — Capture contact details from organizations’ public Facebook presences and enrich company databases for outreach and partnerships. The output is useful when you’re extracting Facebook page phone number and website values alongside email.

**Freelance researchers & analysts** — Deliver clean datasets for audits, market research, and competitor mapping by exporting from the Apify dataset. Fields like `scraped_at` and `success` help you track data freshness and run quality.

**Automation developers (technical teams)** — Integrate a Facebook page email finder into a larger pipeline using Apify API access, then push results into internal systems. This is useful when you need repeatable, scheduled scraping jobs with consistent JSON output.

***

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

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

1. **Open** the actor on Apify — find it in the Apify Console at <https://console.apify.com>.
2. **Enter your inputs** — paste your Facebook page URLs into `facebookPageUrls` (each item should have a `url`).
3. **Configure proxy settings** — if you want improved reliability for larger batches, enable proxy support in the run settings.
4. **Hit Run** — watch the live logs while each page is processed.
5. **View results** — open the Dataset tab to see records saved as each page completes.
6. **Export** — download as JSON, CSV, or Excel directly from the dataset.
7. **Validate fields** — review `EMAIL`, `PHONE`, `ADDRESS`, and `emails_from_bio` to confirm the contact details you need were captured.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Facebook Page Contact Info & Email Scraper plugs directly into your existing workflow.

You can export your dataset from the Apify dataset tab in **JSON, CSV, or Excel**. This makes it easy to use a Facebook page contact info tool with spreadsheets, BI tools, and lead-management systems.

You can also connect the actor to automations via **Apify API access**, **Zapier / Make**, and **webhooks** (triggering downstream actions when a run completes). For deeper setup options and documentation, check the Apify developer docs at <https://apify.com/docs/api>.

***

### Pricing & Free Trial

Facebook Page Contact Info & Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. Free tier typically provides enough platform credits for several test runs, so you can confirm fields like `EMAIL`, `PHONE`, and `ADDRESS` meet your needs.

For production runs, Apify uses pay-as-you-go billing based on Actor compute units (CU) and plan-based access for heavier usage. Start for free at [apify.com](https://apify.com) and scale when you’re ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Request failures | Retries with exponential backoff to improve completion rates |
| Access variability | Built-in resilience so you don’t lose the whole run when a single page fails |
| Data freshness tracking | Each record includes `scraped_at` |
| Live progress visibility | Results are pushed to the dataset as pages are processed |
| Failure states | Records include `success` and may include `error` when a page can’t be processed |

**Limitations:** The actor only extracts data that is publicly available on the provided pages. If a page doesn’t expose contact details (like email or phone) in the bio/About content, the corresponding fields may be missing or empty. 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 on the platform that you can use to run initial tests and validate that the Facebook page email scraper output matches your requirements.

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

No. This actor scrapes contact information from publicly available page content you provide via `facebookPageUrls`.

#### How accurate is the data?

Accuracy depends on what the page owner has published publicly. Facebook Page Contact Info & Email Scraper extracts emails from page bio text into `emails_from_bio`, and also attempts to capture structured contact fields from the About section when present.

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

You can submit a list of Facebook page URLs in `facebookPageUrls`, and the actor will process each one and write a dataset record per page. The practical limits depend on your Apify run settings and platform capacity.

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

The output includes `scraped_at` for each record, so you can track when the contact info was captured. To keep your lead lists fresh, run the actor again on your preferred cadence.

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

This actor is intended for extracting data from **publicly available data**. Compliance with GDPR, CCPA, platform Terms of Service, and any applicable local regulations is your responsibility when you collect, store, or use the data.

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

Yes. You can export your Apify dataset as JSON, CSV, or Excel from the dataset tab, then import it into Google Sheets or any compatible tool.

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

Yes. Apify supports scheduled runs, so you can automate repeated scraping jobs and keep contact lists up to date.

#### Can I access this via API?

Yes. You can trigger runs programmatically and retrieve results via the Apify API—see <https://apify.com/docs/api> for details.

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

If a page fails processing, the actor records the page URL and an error message field while setting `success` to `false` for that record. Pages that succeed are still saved to the dataset as they’re processed.

***

### Need Help or Have a Request?

Got a question about Facebook Page Contact Info & Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We actively maintain this actor based on user feedback.

If you’d like, share ideas like batch CSV upload for Facebook page URLs or webhook notifications when runs complete.

***

### Disclaimer & Responsible Use

*Facebook Page Contact Info & Email Scraper is the fastest, most reliable way to extract Facebook page contact details—start your free run today.*

This actor extracts **publicly available data** from the Facebook pages you provide. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for ensuring your use complies with GDPR, CCPA, platform Terms of Service, and applicable laws. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `facebookPageUrls` (type: `array`):

List of Facebook Page URLs to scrape for contact info.

## Actor input object example

```json
{
  "facebookPageUrls": [
    {
      "url": "https://www.facebook.com/humansofnewyork/"
    },
    {
      "url": "https://www.facebook.com/BlueSpringsSidingandWindows"
    }
  ]
}
```

# 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 = {
    "facebookPageUrls": [
        {
            "url": "https://www.facebook.com/humansofnewyork/"
        },
        {
            "url": "https://www.facebook.com/BlueSpringsSidingandWindows"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/facebook-page-contact-info-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 = { "facebookPageUrls": [
        { "url": "https://www.facebook.com/humansofnewyork/" },
        { "url": "https://www.facebook.com/BlueSpringsSidingandWindows" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/facebook-page-contact-info-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 '{
  "facebookPageUrls": [
    {
      "url": "https://www.facebook.com/humansofnewyork/"
    },
    {
      "url": "https://www.facebook.com/BlueSpringsSidingandWindows"
    }
  ]
}' |
apify call scraperoka/facebook-page-contact-info-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Page Contact Info Scraper",
        "description": "📇 Facebook Page Contact Info Scraper extracts phone, email, website, and other public contact details from Facebook pages. 🚀 Perfect for lead generation, sales outreach, and market research—fast, accurate, and easy to use. 💼",
        "version": "1.0",
        "x-build-id": "8bbpc2vb7WxAZZgiV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~facebook-page-contact-info-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-facebook-page-contact-info-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scraperoka~facebook-page-contact-info-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-facebook-page-contact-info-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scraperoka~facebook-page-contact-info-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-facebook-page-contact-info-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": [
                    "facebookPageUrls"
                ],
                "properties": {
                    "facebookPageUrls": {
                        "title": "Facebook Page Contact Scraper URLs",
                        "type": "array",
                        "description": "List of Facebook Page URLs to scrape for contact info.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
