# 📧 LinkedIn Email Scraper (`scraperx/linkedin-email-scraper`) Actor

Extract professional email data from LinkedIn with speed and accuracy. Find verified business emails, names, job titles, company details, and profile links for outreach, lead generation, and recruiting. Get clean, structured results without manual searching or coding.

- **URL**: https://apify.com/scraperx/linkedin-email-scraper.md
- **Developed by:** [ScraperX](https://apify.com/scraperx) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 9 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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 Email Scraper

The 📧 LinkedIn Email Scraper is a focused LinkedIn email extractor that searches Google for LinkedIn results matching your keywords and pulls publicly visible email addresses straight from the search snippets — fast. It solves the tedious problem of manual contact discovery by acting as a LinkedIn email finder tool for marketers, sales teams, recruiters, researchers, and developers who need to find emails from LinkedIn profiles at scale and export LinkedIn emails to CSV for outreach and enrichment. With clean, structured outputs and automation-ready datasets, you can build a repeatable “LinkedIn outreach email list builder” that scales.

### What data / output can you get?

This actor saves structured records to the Apify dataset. Each item contains:

| Data type | Description | Example value |
| --- | --- | --- |
| network | The network label inferred from platform | Linkedin.com |
| keyword | The keyword that produced the result | marketing |
| title | Result title from the Google SERP block | Social Lift Marketing | LinkedIn |
| description | Result snippet text from the SERP block | Digital marketing services in London — contact us at socialliftmarketing@outlook.com |
| url | The LinkedIn result URL | https://www.linkedin.com/company/socialliftmarketing/ |
| email | Parsed email found in the SERP block | socialliftmarketing@outlook.com |

Notes:
- description may be empty if Google doesn’t show a snippet for a given result.
- Export your dataset to JSON, CSV, or Excel — ideal for “LinkedIn to CRM email export” workflows.

### Key features

- 🔎 Bold keyword-driven extraction  
  Searches Google for LinkedIn content matching your keywords and extracts emails directly from SERP snippets — a streamlined LinkedIn email scraping tool for quick wins.

- 📍 Domain and location filters  
  Use emailDomains to keep only specific domains (e.g., @company.com or @gmail.com) and location to narrow searches — perfect as a LinkedIn B2B email scraper for corporate outreach or personal inbox targeting.

- 🎯 Per‑keyword caps & smart pagination  
  Control volume with maxEmails per keyword. The scraper paginates through results and stops after several empty pages to save time and credits.

- 🧠 Robust email detection & normalization  
  Emails are captured with a resilient regex and text normalization that removes zero‑width characters often present in web content.

- 🛡️ Automatic proxy fallbacks  
  Built‑in resilience with Apify Proxy: starts with GOOGLE_SERP group and can fall back to datacenter and then residential proxies with up to 3 retries to reduce blocking.

- 📦 Structured outputs & easy exports  
  Clean JSON output with fields: network, keyword, title, description, url, email — ready to export LinkedIn emails to CSV/Excel and plug into downstream tools.

- 👨‍💻 Developer‑friendly Apify Actor  
  Results land in an Apify dataset you can fetch via API — ideal for automation pipelines like a LinkedIn lead email extractor or LinkedIn to CRM email export.

- ⚙️ Production‑ready reliability  
  Tuned for search result stability with a legacy engine default and defensive request handling — a practical alternative to fragile browser extensions.

### How to use 📧 LinkedIn Email Scraper - step by step

1. Sign up or log in to your Apify account.  
2. Open the “📧 LinkedIn Email Scraper” actor in the Apify Store.  
3. Add input data:  
   - keywords: list of terms to search for (e.g., ["marketing", "founder"])  
   - Optional filters: location (e.g., "London"), emailDomains (e.g., ["@company.com"]), maxEmails (per keyword)  
   - Optional settings: platform (defaults to "Linkedin"), engine (defaults to "legacy"), proxyConfiguration  
4. Configure proxy settings if needed (proxyConfiguration). The actor will automatically fall back to other proxy groups if Google blocks requests.  
5. Start the run. The actor queries Google with site:linkedin.com + your keywords and parses emails from the results.  
6. Monitor progress in the run logs — you’ll see per‑keyword counts as emails are collected.  
7. Download your results from the Dataset in JSON, CSV, or Excel for “LinkedIn to CRM email export”.  

Pro tip: Use emailDomains to focus on corporate inboxes (e.g., @company.com) or personal inboxes (e.g., @gmail.com, @outlook.com) when you need a targeted LinkedIn contact email finder.

### Use cases

| Use case name | Description |
| --- | --- |
| B2B lead generation from LinkedIn | Build targeted lists and find emails from LinkedIn profiles using keyword searches and domain filters for corporate outreach. |
| Recruiting outreach | Source publicly listed candidate or company contact emails to streamline first‑contact messages without manual profile checks. |
| Influencer and partner discovery | Locate contact emails for creators, agencies, and brands to accelerate collaborations and PR outreach. |
| Sales Navigator prospecting assist | Augment your workflow by extracting emails from Google results for LinkedIn pages — a lightweight “LinkedIn Sales Navigator email scraper” alternative. |
| LinkedIn to CRM email export | Pipe dataset results to your CRM or marketing automation for enrichment and follow‑ups. |
| Academic and market research | Collect samples of publicly displayed contact emails tied to roles, industries, or regions for non‑commercial analysis. |
| Media and PR lists | Assemble journalist and brand contact emails that appear on LinkedIn pages or ABOUT sections visible in SERPs. |

### Why choose 📧 LinkedIn Email Scraper?

Built for precision and reliability, this LinkedIn contact email scraper focuses on public SERP data extraction at scale — without logins or extensions.

- ✅ Accurate, keyword‑driven results with domain and location filtering  
- 🛡️ Reliable Google SERP scraping with automatic proxy fallbacks and retries  
- 📈 Scales by keyword with maxEmails controls for predictable volumes  
- 👩‍💻 Developer access via Apify datasets and API for automation pipelines  
- 🔒 Public‑data only — no LinkedIn login, cookies, or private data access  
- 💰 Cost‑conscious runs thanks to tunable limits and resilient request handling  
- 🚫 LinkedIn email finder Chrome extension alternative — avoids on‑page automation risks  

In short: a focused LinkedIn email finder tool versus unstable browser extensions — stable, structured, and automation‑friendly.

### Is it legal / ethical to use 📧 LinkedIn Email Scraper?

Yes — when done responsibly. This actor extracts public data from Google search results and parses emails that appear in those result snippets for LinkedIn pages.

Guidelines for compliant use:
- Only collect and use publicly displayed emails for legitimate purposes.  
- Respect LinkedIn’s and Google’s terms, and comply with data protection laws (e.g., GDPR, CCPA).  
- Do not use scraped emails for spam or deceptive outreach.  
- This actor does not access private profiles or authenticated data.  
- For edge cases, consult your legal team to confirm compliance.

### Input parameters & output format

#### Example input (JSON)
```json
{
  "keywords": ["marketing", "founder", "business"],
  "platform": "Linkedin",
  "location": "London",
  "emailDomains": ["@gmail.com", "@company.com"],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Parameter reference:

- keywords (array, required) — List of search terms to find LinkedIn profiles or posts. Each keyword is processed separately. Default: none (required)
- platform (string, optional) — Platform to target. Currently supports "Linkedin". Default: "Linkedin"
- location (string, optional) — Optional location filter added to the search query (e.g., "London"). Default: ""
- emailDomains (array, optional) — Keep only emails from these domains (e.g., "@gmail.com", "@outlook.com", "@company.com"). Default: none
- maxEmails (integer, optional) — Maximum number of emails to collect per keyword (1–5000). Default: 20
- engine (string, optional) — Scraping engine. "legacy" uses GOOGLE\_SERP proxy with traditional selectors. Default: "legacy"
- proxyConfiguration (object, optional) — Proxy settings. By default, no proxy is used. If blocked, the actor automatically tries datacenter and then residential proxies with up to 3 retries. Default: {"useApifyProxy": false}

#### Example output (JSON)

Each dataset item is a single JSON object with the following fields:

```json
{
  "network": "Linkedin.com",
  "keyword": "marketing",
  "title": "Social Lift Marketing | LinkedIn",
  "description": "Digital marketing services in London — contact us at socialliftmarketing@outlook.com",
  "url": "https://www.linkedin.com/company/socialliftmarketing/",
  "email": "socialliftmarketing@outlook.com"
}
```

Notes:

- description may be empty if Google doesn’t provide a snippet for that result.
- email is always present for pushed records (the actor filters for results where an email was found and applies emailDomains if provided).

### FAQ

#### Is there a free way to try this LinkedIn email scraping tool?

Yes. You can run the actor on Apify and export results from the dataset. Check the actor’s listing for current pricing and any included trial minutes.

#### Do I need a LinkedIn login or cookies?

No. This LinkedIn email finder tool parses public Google search results for LinkedIn pages and does not require LinkedIn login.

#### Can I use it with Python or via API?

Yes. Results are stored in an Apify dataset you can access through the Apify API, making it easy to integrate with Python scripts or workflows for LinkedIn to CRM email export.

#### Can it export to CSV or Excel?

Yes. You can export LinkedIn emails to CSV, JSON, or Excel directly from the Apify dataset UI or API.

#### Does it work as a Sales Navigator email scraper?

It doesn’t log into Sales Navigator. Instead, it searches Google for LinkedIn pages and extracts emails visible in the SERP snippets — a lightweight alternative for prospecting.

#### How can I find only work emails from LinkedIn?

Use the emailDomains filter (e.g., \["@company.com"]) to keep only corporate domains — a practical way to focus your LinkedIn lead email extractor on business contacts.

#### Can it find emails for LinkedIn company pages and profiles?

It can capture emails if they appear in Google’s snippets for LinkedIn company or profile pages. It does not visit LinkedIn pages directly; it relies on what appears in SERPs.

#### Does it verify emails from LinkedIn profiles?

No. The actor extracts emails that appear in SERP snippets and does not perform email verification. You can combine the output with an external email verification tool if needed.

#### How many emails can I collect per keyword?

You control this with maxEmails (default 20). The actor paginates through Google results and stops when the cap is reached or when several consecutive pages yield no emails.

#### Is this a LinkedIn email finder Chrome extension?

No. It’s a cloud‑based Apify actor — more stable than extensions and easier to automate for LinkedIn email enrichment tool workflows.

### Closing CTA / Final thoughts

This 📧 LinkedIn Email Scraper is built to extract public emails tied to LinkedIn results quickly and reliably. Set your keywords, apply domain/location filters, and export structured outputs for outreach and enrichment. It’s ideal for marketers, sales teams, recruiters, data analysts, and researchers who need a dependable LinkedIn email extractor they can automate. Developers can pull datasets via the Apify API to power pipelines for LinkedIn to CRM email export. Start extracting smarter, faster, and at scale.

# Actor input Schema

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

📌 List of search terms to find LinkedIn profiles or posts (e.g. 'marketing', 'founder', 'business'). The actor searches Google for LinkedIn content containing these keywords and extracts email addresses from the results. Add as many keywords as you need — each will be processed separately.

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

📱 Choose the social/professional platform to scrape. Currently supports LinkedIn — more platforms may be added in future updates.

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

🌍 Optional: Narrow results by location (e.g. 'London', 'New York', 'Berlin'). Added to the search query to find profiles or posts from that area. Leave empty to search globally without a location filter.

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

✉️ Optional: Only keep emails from these domains (e.g. '@gmail.com', '@outlook.com', '@company.com'). Useful for B2B (corporate domains) or personal (Gmail/Outlook). Leave empty to collect emails from all domains.

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

🎯 Cap how many emails to collect for each keyword (1–5000). Stops after reaching this number per keyword, so you can control run time and dataset size. Default: 20.

## `engine` (type: `string`):

🔧 **Legacy:** Uses GOOGLE\_SERP proxy with traditional selectors — more reliable for strict Google results, but slower and typically more expensive. Best when you need consistent, stable results.

## `proxyConfiguration` (type: `object`):

🌐 Choose which proxies to use for requests. By default, no proxy is used. If Google blocks or rejects requests, the actor automatically tries datacenter proxy, then residential proxy, with up to 3 retries — so your run is more resilient.

## Actor input object example

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

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperx/linkedin-email-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperx/linkedin-email-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraperx/linkedin-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📧 LinkedIn Email Scraper",
        "description": "Extract professional email data from LinkedIn with speed and accuracy. Find verified business emails, names, job titles, company details, and profile links for outreach, lead generation, and recruiting. Get clean, structured results without manual searching or coding.",
        "version": "0.1",
        "x-build-id": "geF1Ve8j3eP12LFIN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~linkedin-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-linkedin-email-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/scraperx~linkedin-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-linkedin-email-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/scraperx~linkedin-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-linkedin-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "🔑 Keywords",
                        "type": "array",
                        "description": "📌 List of search terms to find LinkedIn profiles or posts (e.g. 'marketing', 'founder', 'business'). The actor searches Google for LinkedIn content containing these keywords and extracts email addresses from the results. Add as many keywords as you need — each will be processed separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "🌐 Platform",
                        "enum": [
                            "Linkedin"
                        ],
                        "type": "string",
                        "description": "📱 Choose the social/professional platform to scrape. Currently supports LinkedIn — more platforms may be added in future updates.",
                        "default": "Linkedin"
                    },
                    "location": {
                        "title": "📍 Location Filter",
                        "type": "string",
                        "description": "🌍 Optional: Narrow results by location (e.g. 'London', 'New York', 'Berlin'). Added to the search query to find profiles or posts from that area. Leave empty to search globally without a location filter.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "📬 Email Domains Filter",
                        "type": "array",
                        "description": "✉️ Optional: Only keep emails from these domains (e.g. '@gmail.com', '@outlook.com', '@company.com'). Useful for B2B (corporate domains) or personal (Gmail/Outlook). Leave empty to collect emails from all domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "📊 Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "🎯 Cap how many emails to collect for each keyword (1–5000). Stops after reaching this number per keyword, so you can control run time and dataset size. Default: 20.",
                        "default": 20
                    },
                    "engine": {
                        "title": "⚙️ Scraping Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "🔧 **Legacy:** Uses GOOGLE_SERP proxy with traditional selectors — more reliable for strict Google results, but slower and typically more expensive. Best when you need consistent, stable results.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy Configuration",
                        "type": "object",
                        "description": "🌐 Choose which proxies to use for requests. By default, no proxy is used. If Google blocks or rejects requests, the actor automatically tries datacenter proxy, then residential proxy, with up to 3 retries — so your run is more resilient."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
