# Best Facebook Phone Number Scraper (`scraperoka/best-facebook-phone-number-scraper`) Actor

📱🔎 Best Facebook Phone Number Scraper extracts verified contact details from Facebook profiles & pages—fast, accurate, and privacy-minded. 🚀 Perfect for B2B lead gen, sales outreach, and marketing research.

- **URL**: https://apify.com/scraperoka/best-facebook-phone-number-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 Phone Number Scraper 🎯 — Extract Phone Numbers from Public Facebook Profiles, Groups, and Pages Fast

Manually hunting through Facebook profiles, groups, and pages to collect phone numbers wastes hours you don’t have. **Facebook Phone Number Scraper** pulls social contact details at scale so you can build leads faster. This Facebook phone number scraper helps marketers, recruiters, and growth teams scrape Facebook phone numbers using your search terms and a target country. Expect to collect up to thousands of results in minutes—depending on your input limits and data availability.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "keyword": "fitness coaches",
  "title": "Fitness Coaches in Miami",
  "description": "Phone: +1 555-010-2020 | Call us for booking\n\n(Example publicly listed contact info.)",
  "phone_number": "+15550102020",
  "country": "United States",
  "dial_code": "+1",
  "url": "https://www.facebook.com/somepage",
  "source_type": "Groups"
}
````

**Output Fields:**

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | Which search term you used, so you can segment results by campaign or niche (e.g., lead generation facebook phone numbers). |
| `title` | string | The page/profile/group title linked to the extracted contact details. |
| `description` | string | The extracted text content where the phone number was found—useful for auditing and context. |
| `phone_number` | string | The normalized phone number in E.164 format ready for CRM import. |
| `country` | string | The target country label used for formatting/normalization. |
| `dial_code` | string | The dial code associated with the country target (handy for filtering). |
| `url` | string | A direct link to the Facebook page/profile where the contact info was sourced. |
| `source_type` | string | The selected source type (for example, Profiles, Groups, Marketplace), so you know where the phone number came from. |
| `error_message` | string | If an error occurs during a record push, you’ll see it in logs and the run continues incrementally (failure handling is reflected in runtime behavior). |
| `status` | string | Run status is reflected through dataset writing behavior and log messages as the actor proceeds keyword-by-keyword. |

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

***

### Why Facebook Phone Number Scraper?

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

#### Fast Lead Lists Without Manual Copy-Paste

Facebook contact scraper workflows break down when you need scale. This Facebook phone number harvesting tool is built for collecting results in bulk using your `searchTerms` and a controlled phone-number cap.

#### Flexible Source Targeting (Profiles, Groups, Pages)

You can choose what to target using `sourceRegion`, including `Profiles`, `Groups`, and `Marketplace`—making it useful for facebook group members phone numbers and business contact discovery.

#### Clean, Normalized Phone Numbers

The actor normalizes extracted phone numbers into E.164 format via phone number parsing, helping you avoid messy duplicates and inconsistent formats when you build a facebook contact list scraper for outreach.

#### Deduplicated Results With a Hard Output Cap

It keeps track of already-seen numbers during a run, and stops when `maxPhoneNumbers` is reached—so you control volume and get predictable output sizing.

***

### Configuring Your Run

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

```json
{
  "searchTerms": [
    "fitness coaches",
    "real estate agents"
  ],
  "country": "United States (+1)",
  "sourceRegion": "Groups",
  "maxPhoneNumbers": 50
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `searchTerms` | ✅ | Enter keywords to find Facebook profiles/pages (for example, “Fitness Coaches” or “Real Estate”). |
| `country` | ✅ | Select the country to target for phone-number formatting and targeting. |
| `sourceRegion` | ✅ | Choose the type of Facebook page to target: `All`, `Profiles`, `Reels`, `Posts`, `Groups`, `Videos`, `Photos`, `Events`, or `Marketplace`. |
| `maxPhoneNumbers` | ✅ | Stop scraping after this many phone numbers are found (set a cap for testing or lead list sizing). |

***

### Core Capabilities

#### Keyword-Driven Facebook Contact Discovery

Use `searchTerms` to drive what gets collected. This makes the Facebook phone number scraper a practical facebook contact scraper for lead generation facebook phone numbers and niche research.

#### Source-Type Control for Better Relevance

With `sourceRegion`, you decide whether you want contact details from `Profiles`, `Groups`, `Marketplace`, and more. This is especially helpful when you’re looking for phone numbers that belong to community or business-style areas like Groups and Pages.

#### Resilient Data Collection Behavior

The actor is designed to continue working and write results incrementally as it processes data. That means you can stop and resume without losing already pushed output from earlier progress.

#### Normalized Phone Numbers for CRM Readiness

Extracted numbers are parsed and formatted into E.164 style output via phone-number handling logic. This keeps your datasets consistent when you’re later combining results into spreadsheets, CRMs, or outreach tools.

#### Dataset Output Built for Immediate Export

Each discovered entry is pushed to the dataset with fields like `phone_number`, `url`, `keyword`, and `source_type`. That structure makes it easy to export and analyze immediately after a run.

***

### Who Gets the Most Out of This

Here's how different teams put **Facebook Phone Number Scraper** to work:

**Sales and Business Development Teams** — Feed in relevant `searchTerms` (like real estate agents) and set `sourceRegion` to focus on the most useful Facebook areas. You end up with a cleaner lead list of phone numbers with source links for follow-up and validation.

**Recruiters and Talent Sourcers** — Use targeted search terms to find organizations and communities that list direct contact lines. The output helps you build a faster shortlist for outreach without spending days manually collecting contacts.

**Community and Partnership Managers** — If you’re exploring contacts from facebook group members phone numbers, choosing `sourceRegion: "Groups"` can help you locate publicly listed community contacts more efficiently.

**Data Analysts and Researchers** — Because results include `keyword`, `country`, `dial_code`, `source_type`, and `url`, it’s easier to quantify where contacts come from and how phone data availability changes across source types.

**Automation Specialists (Technical Users)** — Use the structured dataset fields to feed downstream workflows. This makes it suitable for automation scenarios like scheduled enrichment and repeated lead harvesting runs driven by input parameters.

***

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

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

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and search for *Facebook Phone Number Scraper*.
2. **Enter your inputs** — set `searchTerms`, `country`, `sourceRegion`, and `maxPhoneNumbers` exactly as shown in the input table above.
3. **Configure proxy settings (optional but recommended)** — enable the built-in proxy support in Apify for more reliable scraping at scale.
4. **Hit Run and watch the live log** — monitor progress while results are pushed incrementally.
5. **View results in the dataset tab** — review `phone_number` and `url` together so you can validate sources quickly.
6. **Export as JSON, CSV, or Excel** — download your dataset from the Apify dashboard in the format that fits your workflow.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Facebook Phone Number Scraper** plugs directly into your existing workflow.

You can export results in **JSON, CSV, or Excel** directly from the dataset tab in the Apify dashboard. From there, you can import into your CRM, spreadsheets, or contact database for lead management.

For automation and advanced pipelines, you can also connect Apify via the **Apify API** (see documentation at https://apify.com/docs/api) and trigger downstream actions using **webhooks**. If you prefer no-code tools, you can use **Zapier / Make** style workflows to push results to wherever your team manages leads, and schedule recurring runs for continuous facebook data scraper collection.

***

### Pricing & Free Trial

Facebook Phone Number Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

You generally get free trial-style exploration through platform credits, and then scaling happens using Apify’s pay-as-you-go compute model. For precise pricing details (including how credits map to runs and compute usage), check the pricing on the Apify pricing page. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limit pressure | Uses built-in resiliency and controlled pacing so jobs can complete reliably. |
| Scraping stability | Built-in proxy support for reliable scraping. |
| Deduplication | Avoids re-adding the same phone number within a run. |
| Incremental progress | Pushes results to the dataset as it goes, so partial runs still produce usable output. |
| Output predictability | Enforces `maxPhoneNumbers` as a stop condition. |

**Limitations:** The actor only works with data available from publicly accessible sources. If phone numbers are not present in the targeted public content, you may see fewer results than `maxPhoneNumbers`.

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

***

### Frequently Asked Questions

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

Yes. The actor runs on Apify, which offers a **free tier** so you can test smaller jobs before scaling up.

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

No. Facebook Phone Number Scraper is designed to work with publicly available sources, so you don’t need to log in or manage Facebook sessions.

#### How accurate is the data?

The phone numbers come from publicly available text content that contains contact information, and the actor formats extracted matches into normalized phone output. Accuracy depends on what phone numbers are actually published in the source content.

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

You control the cap using `maxPhoneNumbers`. The actor stops when it reaches that limit, so you can reliably size your lead lists for outreach.

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

Freshness depends on when Facebook content is publicly available and changes over time. The actor doesn’t guarantee a specific update frequency—each run reflects what’s accessible at the moment you execute the job.

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

This actor collects **publicly available data**. It’s still your responsibility to comply with GDPR, CCPA, applicable platform terms, and any local regulations when storing and using the collected phone numbers.

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

Yes. You can export your dataset as JSON, CSV, or Excel directly from the Apify dashboard, and then import into tools like spreadsheets as needed.

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

Yes. Since it runs on Apify, you can schedule runs so Facebook phone number scraping happens automatically at intervals that match your lead-generation cadence.

#### Can I access this via API?

Yes. You can trigger runs and retrieve results programmatically through the Apify API (documentation: https://apify.com/docs/api).

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

If an error occurs during record handling, the actor behavior is logged and runs continue incrementally as results are pushed to the dataset. This helps reduce the chance of losing already collected data in a long job.

***

### Need Help or Have a Request?

Got a question about **Facebook Phone Number Scraper** or want a new feature added? Reach out at <dataforleads@gmail.com>. We actively maintain the actor based on user feedback and respond quickly. If you have specific ideas like webhook notifications on completion or enhanced export formatting, tell us what you need.

***

### Disclaimer & Responsible Use

*Facebook Phone Number Scraper is the fastest, most reliable way to build outreach-ready phone number datasets — start your free run today.*

This actor collects **publicly available data** from Facebook and does not access private accounts, login-gated content, or password-protected pages. You are responsible for ensuring your use complies with GDPR, CCPA, platform ToS, and any applicable local regulations. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `country` (type: `string`):

Select the country to target for Google search results.

## `maxPhoneNumbers` (type: `integer`):

Stop scraping after this many phone numbers are found.

## `searchTerms` (type: `array`):

Enter keywords to find Facebook profiles/pages (e.g., 'Fitness Coaches', 'Real Estate').

## `sourceRegion` (type: `string`):

Select the type of Facebook page to target.

## Actor input object example

```json
{
  "country": "United States (+1)",
  "maxPhoneNumbers": 20,
  "searchTerms": [
    "fitness coaches",
    "real estate agents"
  ],
  "sourceRegion": "All"
}
```

# 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 = {
    "searchTerms": [
        "fitness coaches",
        "real estate agents"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/best-facebook-phone-number-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 = { "searchTerms": [
        "fitness coaches",
        "real estate agents",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/best-facebook-phone-number-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 '{
  "searchTerms": [
    "fitness coaches",
    "real estate agents"
  ]
}' |
apify call scraperoka/best-facebook-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Best Facebook Phone Number Scraper",
        "description": "📱🔎 Best Facebook Phone Number Scraper extracts verified contact details from Facebook profiles & pages—fast, accurate, and privacy-minded. 🚀 Perfect for B2B lead gen, sales outreach, and marketing research.",
        "version": "1.0",
        "x-build-id": "v0tJUuA1uqhqRikdD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~best-facebook-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-best-facebook-phone-number-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~best-facebook-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-best-facebook-phone-number-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~best-facebook-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-best-facebook-phone-number-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": [
                    "searchTerms",
                    "country",
                    "sourceRegion",
                    "maxPhoneNumbers"
                ],
                "properties": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "United States (+1)",
                            "United Kingdom (+44)",
                            "Canada (+1)",
                            "Australia (+61)",
                            "Germany (+49)",
                            "France (+33)",
                            "India (+91)",
                            "Japan (+81)",
                            "Brazil (+55)",
                            "Italy (+39)",
                            "Spain (+34)",
                            "Netherlands (+31)",
                            "Sweden (+46)",
                            "Norway (+47)",
                            "Denmark (+45)",
                            "Finland (+358)",
                            "Poland (+48)",
                            "Czech Republic (+420)",
                            "Hungary (+36)",
                            "Romania (+40)",
                            "Bulgaria (+359)",
                            "Croatia (+385)",
                            "Slovenia (+386)",
                            "Slovakia (+421)",
                            "Estonia (+372)",
                            "Latvia (+371)",
                            "Lithuania (+370)",
                            "Portugal (+351)",
                            "Greece (+30)",
                            "Cyprus (+357)",
                            "Malta (+356)",
                            "Luxembourg (+352)",
                            "Ireland (+353)",
                            "Belgium (+32)",
                            "Austria (+43)",
                            "Switzerland (+41)",
                            "Liechtenstein (+423)",
                            "Iceland (+354)",
                            "South Korea (+82)",
                            "China (+86)",
                            "Mexico (+52)",
                            "Argentina (+54)",
                            "Chile (+56)",
                            "Colombia (+57)",
                            "Peru (+51)",
                            "Venezuela (+58)",
                            "Ecuador (+593)",
                            "Uruguay (+598)",
                            "Paraguay (+595)",
                            "Bolivia (+591)",
                            "Saudi Arabia (+966)",
                            "United Arab Emirates (+971)",
                            "Bahrain (+973)",
                            "Israel (+972)",
                            "Jordan (+962)",
                            "Kuwait (+965)",
                            "Lebanon (+961)",
                            "Oman (+968)",
                            "Qatar (+974)",
                            "Bangladesh (+880)",
                            "Pakistan (+92)",
                            "Sri Lanka (+94)",
                            "Thailand (+66)",
                            "Viet Nam (+84)",
                            "Malaysia (+60)",
                            "Singapore (+65)",
                            "Philippines (+63)",
                            "Indonesia (+62)",
                            "New Zealand (+64)",
                            "South Africa (+27)",
                            "Turkey (+90)",
                            "Ukraine (+380)",
                            "Russia (+7)"
                        ],
                        "type": "string",
                        "description": "Select the country to target for Google search results.",
                        "default": "United States (+1)"
                    },
                    "maxPhoneNumbers": {
                        "title": "Max Phone Numbers",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop scraping after this many phone numbers are found.",
                        "default": 20
                    },
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Enter keywords to find Facebook profiles/pages (e.g., 'Fitness Coaches', 'Real Estate').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sourceRegion": {
                        "title": "Source Type",
                        "enum": [
                            "All",
                            "Profiles",
                            "Reels",
                            "Posts",
                            "Groups",
                            "Videos",
                            "Photos",
                            "Events",
                            "Marketplace"
                        ],
                        "type": "string",
                        "description": "Select the type of Facebook page to target.",
                        "default": "All"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
