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

🔍 Best LinkedIn Phone Number Scraper helps you extract verified phone numbers from LinkedIn profiles fast and accurately. 🚀 Perfect for B2B lead gen, sales outreach, and recruitment—streamline research and boost conversion rates. 📈💼

- **URL**: https://apify.com/scrapeflux/best-linkedin-phone-number-scraper.md
- **Developed by:** [ScrapeFlux](https://apify.com/scrapeflux) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### LinkedIn Phone Number Scraper ⚡

Trying to scrape phone numbers from LinkedIn manually wastes hours and still misses key leads. **LinkedIn Phone Number Scraper** automates the process by extracting phone numbers from publicly available web data and pushing results directly into your Apify dataset. This LinkedIn phone number scraper (and LinkedIn contact scraper) is built for lead generation phone scraper workflows and LinkedIn email and phone scraper-style enrichment. Use it if you need a LinkedIn data extraction phone numbers list for outreach, research, or B2B prospecting—fast. In one run, you can collect up to **maxPhoneNumbers** unique phone numbers (with a free-plan cap), saving your team from repetitive copy-paste work.

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
{
  "keyword": "marketing manager",
  "title": "Acme Inc — Marketing Manager",
  "description": "Call us at +1 415 555 0134 or contact support at support@acme.com.",
  "phone_number": "+14155550134",
  "country": "United States",
  "dial_code": "+1",
  "url": "https://www.linkedin.com/company/acme-inc/",
  "source_type": "Company",
  "status": "success"
}
````

**Output Fields**

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | The specific keyword that drove the match, useful for tracking what lead sources perform best. |
| `title` | string | The page result title associated with the extracted number—helpful for context when reviewing leads. |
| `description` | string | The extracted text snippet where the phone number was found, so you can validate relevance quickly. |
| `phone_number` | string | The unique phone number in E.164 format, ready for importing into your CRM or lists. |
| `country` | string | The target country label you selected for the run (e.g., the United States). |
| `dial_code` | string | The dial code associated with the extracted number for quick filtering and regional reporting. |
| `url` | string | A direct link to the source page where the phone number was found. |
| `source_type` | string | The selected LinkedIn page type targeted for the extraction (All, Profile, Company, Posts, Pulse). |
| `status` | string | Indicates whether the row was successfully pushed as a result (the actor pushes results incrementally). |
| `error_message` | string | null | Present if an error occurs while pushing a result (push failures are logged). |

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": ["ceo", "marketing manager", "founder"],
  "country": "United States (+1)",
  "sourceRegion": "Company",
  "maxPhoneNumbers": 50
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `searchTerms` | ✅ | Enter keywords to find LinkedIn profiles/companies (e.g., `CEO`, `Marketing Managers`, `Tech Startups`). |
| `country` | ✅ | Select the country to target for results, including the dial code (for example, `United States (+1)`). |
| `sourceRegion` | ✅ | Select the type of LinkedIn page to target: `All`, `Profile`, `Company`, `Posts`, or `Pulse`. |
| `maxPhoneNumbers` | ✅ | Stop scraping after this many phone numbers are found (bounded between 1 and 10000). |

***

### What It Does

LinkedIn Phone Number Scraper extracts phone numbers and related context fields, then writes the results to an Apify dataset as it goes.

#### Automated LinkedIn phone number extraction at scale

It helps you scrape phone numbers from LinkedIn-focused publicly available sources using the keywords and limits you set. Each result includes the extracted `phone_number` plus contextual fields like `title`, `description`, and `url`.

#### Uses country targeting for cleaner results

You choose a `country` such as `United States (+1)` and the actor applies that targeting across the run. This makes it easier to build region-specific lists, a common need in LinkedIn lead scraper phone numbers workflows.

#### Clean, integration-ready dataset rows

Every pushed record includes consistent fields: `keyword`, `title`, `description`, `phone_number`, `country`, `dial_code`, `url`, and `source_type`. That structure makes it easier to move from LinkedIn email and phone scraper use cases into spreadsheets and CRMs.

#### Includes resiliency and incremental saving

The actor pushes results incrementally and tracks progress so you can resume without losing already collected data. If a result push fails, the actor logs the error rather than hiding the entire run.

#### Works across LinkedIn page types

With `sourceRegion`, you can target `Profile`, `Company`, `Posts`, `Pulse`, or go broad with `All`. This flexibility supports LinkedIn B2B phone list scraper use cases that need different contact contexts.

Overall, LinkedIn Phone Number Scraper turns “scrape phone numbers from LinkedIn” into a repeatable export you can run, review, and integrate.

***

### Why LinkedIn Phone Number Scraper?

There are plenty of ways to pull contact details from LinkedIn sources—here’s why LinkedIn Phone Number Scraper stands out.

#### Results with immediate dataset output

You don’t have to wait until the end to see progress—rows are written to your dataset as they’re found. This is especially helpful when building a LinkedIn contacts exporter or iterating on keyword sets.

#### Practical limits with `maxPhoneNumbers`

You control how many unique numbers to collect with `maxPhoneNumbers`. That makes it easier to run quick tests for LinkedIn phone number enrichment before scaling up.

#### Flexible targeting with `sourceRegion`

You can choose `Profile`, `Company`, `Posts`, `Pulse`, or `All`, letting you match the extraction to your outreach strategy. For example, personal lead campaigns often map well to `Profile`, while sales prospecting often benefits from `Company`.

***

### Real-World Use Cases

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

**Sales Development Representatives**\
A SDR has a list of target roles and needs a phone-based follow-up list quickly. They run LinkedIn phone number scraper jobs with `searchTerms` like `marketing manager` and limit output with `maxPhoneNumbers`, producing a ready-to-import list with `phone_number`, `url`, and `source_type`. The result is faster prospecting time and less manual research.

**Marketing Teams Building ABM Lists**\
A B2B marketing team wants phone and company contact context for account-based campaigns. They set `sourceRegion` to `Company` and run LinkedIn data extraction phone numbers searches by keyword, then use the dataset’s `dial_code` and `country` for segmentation. The output supports consistent enrichment alongside email lists.

**Lead Researchers & Analysts**\
A researcher is benchmarking which roles are easiest to enrich with phone numbers from public sources. They run LinkedIn email and phone scraper style extraction using multiple keywords, then analyze the dataset’s `keyword`, `title`, and `description` for patterns in availability. Because the output is structured, it’s straightforward to compare runs.

**Outreach Operations for Multi-Region Campaigns**\
An outreach operator needs regional lead lists rather than one global dump. They run LinkedIn contact scraper jobs per `country`, then filter and route results to region-specific sequences using `dial_code` and `source_type`. This keeps follow-up workflows aligned with geography.

**Automation Specialists & Developers**\
A developer needs a reliable data source for enrichment pipelines. They trigger LinkedIn prospecting phone number tool runs and programmatically consume the dataset output fields (`phone_number`, `url`, `source_type`) to feed downstream systems. The consistent dataset schema makes integration simpler for scheduled jobs.

***

### How to Run It

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

1. **Open the actor on Apify**\
   Go to the actor page on Apify: https://console.apify.com.

2. **Enter your inputs**\
   Set `searchTerms`, choose `country`, pick `sourceRegion` (All / Profile / Company / Posts / Pulse), and set `maxPhoneNumbers`.

3. **Configure proxy settings (optional)**\
   If your account or workload benefits from it, enable proxy support via the Apify console for better reliability.

4. **Start the run and watch the live log**\
   Monitor the actor logs to confirm it’s finding results and pushing data.

5. **Open the Dataset tab**\
   Your dataset fills incrementally as records are found—perfect for quickly validating output quality.

6. **Export in your preferred format**\
   Download your results as JSON, CSV, or Excel from the Apify dashboard.

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

***

### Export & Integration Options

Once your data is collected, LinkedIn Phone Number Scraper fits directly into your existing workflow. Export formats are available straight from the Apify dataset tab, including **JSON, CSV, and Excel**, so you can use the data in spreadsheets, CRMs, and enrichment steps.

You can also connect results to your automation stack using Apify-native capabilities and no-code tools like **Zapier** or **Make**, or pull the dataset programmatically via the **API**. If your workflow needs chaining, you can trigger downstream actions using **webhooks** or run it on a **schedule** for ongoing LinkedIn phone number enrichment.

***

### Pricing

LinkedIn Phone Number Scraper runs on Apify, which includes a **free tier** — no credit card needed to start. The actor enforces a free-plan limitation for results, while paid usage removes those restrictions. For larger workloads, Apify uses subscription plans and pay-as-you-go style compute billing per run—check the Apify pricing page for the latest details. Start free at [apify.com](https://apify.com) — scale up when you need to.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Incremental dataset writing | Results are pushed as they’re found so you don’t lose progress mid-run. |
| Resume capability | The actor stores progress so it can continue without restarting from scratch. |
| Error handling during result push | Push failures are logged so you can troubleshoot without losing the whole dataset. |
| User-defined output caps | `maxPhoneNumbers` stops the run once you reach your target. |

Limitations: this actor extracts phone numbers from publicly available sources and can’t access login-gated or private content. Phone availability depends on what’s published on the target sources, so some runs may include fewer numbers than expected.

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, and the actor applies a result limit when you run on the free plan.

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

No. This actor is designed to extract information from publicly available data sources, so you don’t need a LinkedIn login to run it.

#### How accurate is the extracted data?

Accuracy depends on what’s publicly available in the source content. The actor extracts phone numbers and includes contextual fields like `description` and `url` so you can review results quickly.

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

You control the number of phone numbers collected using `maxPhoneNumbers`. On the free tier, a maximum cap may be applied; paid usage has no result limit restrictions based on the code.

#### How fresh is the data?

The data freshness depends on what is currently published in the publicly available sources when you run the actor. For time-sensitive lists, run it on a schedule and re-export as needed.

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

The actor only works with **publicly available data** that can be accessed without login. It’s still your responsibility to ensure your use of the dataset complies with applicable laws (including GDPR/CCPA), platform terms, and local regulations.

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

Yes. You can export from the Apify dashboard as JSON, CSV, or Excel, and then import into Google Sheets or any CRM that accepts CSV/Excel formats.

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

Yes. In Apify, you can schedule actor runs so your LinkedIn contact scraper phone lists stay up to date.

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

Yes. You can use Apify API access to retrieve the dataset programmatically after the run completes.

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

If an individual result push fails, the actor logs the error and continues processing. Runs also store progress so you can resume instead of starting over.

***

### Get Help & Use Responsibly

Got a question about LinkedIn Phone Number Scraper or a feature you'd like added? Reach out at <dataforleads@gmail.com>. We’re happy to help with setup questions and improvements like additional source targeting options.

**LinkedIn Phone Number Scraper collects only publicly available data**. It does not access private accounts, login-gated pages, or password-protected content. You are responsible for complying with GDPR, CCPA, and any applicable platform ToS when using the exported 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 LinkedIn profiles/companies (e.g., 'CEO', 'Marketing Managers', 'Tech Startups').

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

Select the type of LinkedIn page to target.

## Actor input object example

```json
{
  "country": "United States (+1)",
  "maxPhoneNumbers": 20,
  "searchTerms": [
    "ceo",
    "marketing manager",
    "founder"
  ],
  "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": [
        "ceo",
        "marketing manager",
        "founder"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeflux/best-linkedin-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": [
        "ceo",
        "marketing manager",
        "founder",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapeflux/best-linkedin-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": [
    "ceo",
    "marketing manager",
    "founder"
  ]
}' |
apify call scrapeflux/best-linkedin-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Best Linkedin Phone Number Scraper",
        "description": "🔍 Best LinkedIn Phone Number Scraper helps you extract verified phone numbers from LinkedIn profiles fast and accurately. 🚀 Perfect for B2B lead gen, sales outreach, and recruitment—streamline research and boost conversion rates. 📈💼",
        "version": "1.0",
        "x-build-id": "ni6dQ8camYRJt69SW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeflux~best-linkedin-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeflux-best-linkedin-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-linkedin-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeflux-best-linkedin-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-linkedin-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeflux-best-linkedin-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 LinkedIn profiles/companies (e.g., 'CEO', 'Marketing Managers', 'Tech Startups').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sourceRegion": {
                        "title": "Source Type",
                        "enum": [
                            "All",
                            "Profile",
                            "Company",
                            "Posts",
                            "Pulse"
                        ],
                        "type": "string",
                        "description": "Select the type of LinkedIn 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
