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

📲✨ Best Facebook Phone Number Scraper extracts phone numbers from public Facebook profiles efficiently. ✅ Built for lead generation, outreach & B2B research. Export-ready results for faster targeting and smarter sales campaigns.

- **URL**: https://apify.com/scrapeflux/best-facebook-phone-number-scraper.md
- **Developed by:** [ScrapeFlux](https://apify.com/scrapeflux) (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 $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Facebook Phone Number Scraper ⚡

Trying to find phone numbers from Facebook profiles, groups, and pages manually is slow—and outreach lists quickly become outdated. **Facebook Phone Number Scraper** automates extracting phone numbers from public web data so you can build leads faster. It’s a practical **facebook contact scraper** and **facebook phone number extraction tool** for marketers and researchers who need volume without the copy‑paste grind. Use it for **facebook leads phone scraper** workflows, from first-pass prospecting to cleaner targeting with dial codes and source context. In one run, you can collect up to your configured limit of unique phone numbers while the actor writes results incrementally to your dataset.

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
{
  "keyword": "real estate agents",
  "title": "Example Real Estate Group",
  "description": "Call us at +1-555-0123 or contact our team via WhatsApp.",
  "phone_number": "+15550123",
  "country": "United States",
  "dial_code": "+1",
  "url": "https://www.facebook.com/groups/example-real-estate-group/",
  "source_type": "Groups",
  "status": "success",
  "error_message": null
}
````

Below are the fields the actor writes into the dataset:

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | The keyword from your `searchTerms` that led to this result (useful for segmenting leads). |
| `title` | string | The title text found near the listing you extracted from (helps you understand what the page/group is). |
| `description` | string | The text the actor used when extracting the phone number, so you can verify context later. |
| `phone_number` | string | The unique extracted phone number in E.164 format, ready for enrichment or dialing. |
| `country` | string | The targeted country name you selected in `country` (helps with localization and reporting). |
| `dial_code` | string | The dial code mapped for the selected country (handy for normalization in CRMs). |
| `url` | string | The source page URL where the phone number was found (for auditing and follow-up). |
| `source_type` | string | The selected `sourceRegion` value (e.g., Profiles, Groups, Marketplace) that shaped what you pulled. |
| `status` | string | Indicates whether the row represents a successful extraction vs. an error condition. |
| `error_message` | string | Error details when something goes wrong; `null` when extraction is successful. |

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

***

### Setting It Up

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

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

| Parameter | Required | What It Does |
|---|---|---|
| `searchTerms` | ✅ | A list of keywords used to discover relevant Facebook profiles/pages for phone number extraction. |
| `country` | ✅ | Select the country to target so extraction and dial-code handling match your desired market. |
| `sourceRegion` | ✅ | Chooses the type of Facebook content to target (All, Profiles, Reels, Posts, Groups, Videos, Photos, Events, Marketplace). |
| `maxPhoneNumbers` | ✅ | Stop scraping after this many phone numbers are found (a cap to keep runs focused). |

***

### What It Does

Facebook Phone Number Scraper extracts phone numbers from publicly available Facebook content and stores each match as a structured dataset row.

#### Extracts Phone Numbers for Lead-Gen Workflows

You provide `searchTerms` and a target `country`, and the actor extracts phone numbers and normalizes them using the phone-number formatting logic in the run. This makes results more usable for outreach pipelines and segmentation—without manual searching.

#### Supports Multiple Facebook Source Types

By setting `sourceRegion`, you can aim your facebook profile phone scraper at what you care about most, whether that’s Profiles, Groups, Marketplace, or broader coverage with `All`. This lets teams tailor their lead hunt and avoid getting overwhelmed by irrelevant sources.

#### Produces Clean, Dataset-Ready Output

Every found phone number is pushed with consistent fields like `phone_number`, `country`, `dial_code`, `url`, and `source_type`. The dataset also includes the associated `keyword`, `title`, and `description` so analysts and marketers can audit and refine results later (useful for a facebook phone number finder tool style workflow).

#### Stops at Your Defined Limits

`maxPhoneNumbers` acts as a hard stop for how many phone numbers the actor should collect in a run. This helps keep your facebook leads phone scraper outputs tightly scoped for tests, campaigns, or quota-based processes.

#### Handles Failures Without Losing Captured Data

Results are pushed incrementally to your dataset as they’re found. If runs are interrupted, you still keep the work completed up to that point, and the actor maintains progress so you can resume with less wasted effort—ideal when you’re scraping facebook phone numbers in repeated batches.

Overall, Facebook Phone Number Scraper helps you move from “how to scrape facebook phone numbers” to a ready-to-use dataset quickly and reliably.

***

### Why Facebook Phone Number Scraper?

There are plenty of ways to pull contact data from Facebook—but here’s why Facebook Phone Number Scraper stands out.

#### Built for Faster Prospecting at Scale

Instead of manual browsing, this facebook contact scraper helps you turn keyword targets into structured phone-number leads. You set `maxPhoneNumbers` to control run size and keep results action-focused for outreach.

#### Clear, Consistent Output for Analysts and Marketers

You get dataset rows with `phone_number`, `dial_code`, `country`, and `url`, along with context (`title` and `description`). That structure makes it easier to clean, enrich, and deduplicate in your own systems—useful when you’re building a facebook data scraping tool workflow.

#### Designed to Be Usable in Real Lead Operations

The actor is structured around `searchTerms`, `sourceRegion`, and `country`, matching how lead teams think about segmentation. If you’re running a facebook b2b lead scraper phone process, the source type and keyword linkage help you understand what drove each match.

***

### Real-World Use Cases

**Sales Teams**\
Your team needs fast, phone-first leads for a new territory. You run Facebook Phone Number Scraper with a handful of targeted `searchTerms`, set `sourceRegion` to Groups, and cap `maxPhoneNumbers` for a practical pilot. Within the same run, you get a table of phone numbers with `url` references so SDRs can verify and personalize outreach quickly.

**Marketing Agencies**\
You’re building campaign lists for clients who care about specific niches (like “real estate agents”). You run facebook phone number extraction tool searches by `searchTerms`, choose a market with `country`, and set `sourceRegion` to concentrate on the most relevant content types. The dataset output helps you deliver clean imports for outreach tools without hand-cleaning messy notes.

**Freelance Researchers**\
You’re preparing a contact dataset for a study and need traceable sources. Facebook Phone Number Scraper returns `description` and `url` so you can document where each number came from, not just the phone itself. This makes it easier to justify selections and maintain data quality across iterations.

**Developers & Automation Specialists**\
You want to integrate a facebook messenger phone number scraper style dataset into your pipeline. After running the actor, you export the dataset from Apify and connect it to downstream steps (like enrichment and CRM loading). The consistent fields like `phone_number`, `source_type`, and `dial_code` make automation straightforward.

**Lead Ops / Data Quality Work**\
You need deduped phone numbers in a predictable format for routing. Because results are limited by `maxPhoneNumbers` and include `country` and `dial_code`, you can standardize lead handling rules more easily. This reduces wasted time compared to building lists manually—especially when scraping facebook phone numbers repeatedly for new campaigns.

***

### How to Run It

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

1. **Open the actor page on Apify**\
   Go to [console.apify.com](https://console.apify.com) and find the actor listing for Facebook Phone Number Scraper.

2. **Enter your inputs**\
   Set `searchTerms`, choose `country`, pick a `sourceRegion`, and set `maxPhoneNumbers` to control how many results you want.

3. **Configure proxy settings (optional but recommended)**\
   If your environment uses proxies, configure proxy preferences to help keep scraping stable across larger runs.

4. **Start the run and watch the live log**\
   Monitor progress while the actor extracts phone numbers and pushes results incrementally.

5. **Open the Dataset tab to see live results**\
   You’ll see rows being added with fields like `phone_number`, `url`, and `source_type`.

6. **Export in your preferred format**\
   Download your dataset as JSON, CSV, or Excel directly from the Apify dashboard when the run finishes (or whenever you stop).

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

***

### Export & Integration Options

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

You can export the dataset from the Apify dashboard in **JSON, CSV, or Excel**. This makes it easy to share results with stakeholders or import into tools that accept tabular formats.

If you want to automate the flow, you can use **Apify API access**, connect results via **Zapier or Make**, and trigger downstream steps with **webhooks** when a run completes. For deeper integration details, check the Apify documentation for the actor API and dataset usage.

***

### Pricing

Facebook Phone Number Scraper runs on Apify, which includes a **free tier**—no credit card needed to start. The free tier provides $5 platform credits on sign-up, enough for several real test runs.

After that, pay-as-you-go is billed per Actor compute unit (CU), so you’re not locked into a monthly commitment for occasional scraping needs. Subscription plans are available for heavier workloads—use the Apify pricing page to confirm the latest options. Start free at [apify.com](https://apify.com) — scale up when you need to.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Proxy support | Uses your run configuration to help scraping remain stable in practice. |
| Incremental dataset writing | Pushes results as they are found so progress isn’t lost. |
| Progress persistence | Maintains progress so you can resume without starting over. |
| Result caps | Enforces your `maxPhoneNumbers` stopping point. |
| Error visibility | Includes an error field (`error_message`) when something fails. |

Limitations: this actor works only with publicly available information. It does not guarantee that every discovered profile/page contains a phone number, and results depend on what contact data is actually published on the source.

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

***

### Frequently Asked Questions

#### Is there a free plan?

Yes. Apify offers a free tier with usage credits so you can run Facebook Phone Number Scraper for testing without a credit card.

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

No. Facebook Phone Number Scraper is designed to work with publicly available information that doesn’t require login-gated access.

#### How accurate is the extracted data?

Accuracy depends on what’s published on the source pages. The actor extracts phone numbers from the available text it processes and outputs them in a standardized `phone_number` format.

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

You control the cap using `maxPhoneNumbers`. The actor stops when it reaches the number of unique phone numbers found up to that limit.

#### How fresh is the data?

Data freshness depends on what is currently available on the public pages at run time. If you need the latest information, run the actor again for updated results.

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

The actor is intended to work with **publicly available data**. It’s your responsibility to comply with GDPR, CCPA, platform Terms of Service, and any applicable local regulations when using or storing the extracted phone numbers.

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

Yes. You can export your dataset from the Apify dashboard as JSON, CSV, or Excel, then import into Google Sheets or other tools that accept these formats.

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

Yes. On Apify, you can schedule actor runs to execute automatically on a cron-like schedule. This is helpful for ongoing lead generation cycles using keywords and dial-code targeting.

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

Yes. You can retrieve results programmatically using the Apify API. This is useful if you want to push facebook leads phone scraper outputs into your CRM pipeline automatically.

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

If an extraction fails, the run continues with dataset results written incrementally, and failures are represented with an `error_message` field. Progress is also maintained so you can resume rather than losing earlier work.

***

### Get Help & Use Responsibly

Got a question about Facebook Phone Number Scraper or a feature you'd like added? Reach out at <dataforleads@gmail.com>. We’re happy to hear feedback—especially ideas like better keyword batching for facebook phone number extraction tool workflows or export formatting improvements for faster importing.

**Facebook Phone Number Scraper collects data only from publicly available data.** It does not access private accounts, login-gated pages, or password-protected content. You’re responsible for complying with GDPR, CCPA, and the platform’s Terms of Service when using the data. 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("scrapeflux/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("scrapeflux/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 scrapeflux/best-facebook-phone-number-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapeflux/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 phone numbers from public Facebook profiles efficiently. ✅ Built for lead generation, outreach & B2B research. Export-ready results for faster targeting and smarter sales campaigns.",
        "version": "1.0",
        "x-build-id": "7xaEXGJt0G4dbaf5I"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeflux~best-facebook-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeflux-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/scrapeflux~best-facebook-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeflux-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/scrapeflux~best-facebook-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeflux-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
