# Linkedin Email Scraper (`scraper-engine/linkedin-email-scraper`) Actor

LinkedIn Email Scraper extracts publicly available email addresses from LinkedIn profiles and linked websites. Build targeted contact lists by role, industry, or company. Ideal for sales teams running outbound campaigns.

- **URL**: https://apify.com/scraper-engine/linkedin-email-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Automation, Social media
- **Stats:** 37 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## 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 📱

Linkedin Email Scraper enables users to **extract** a wide range of **data** from **LinkedIn** profiles, focusing on email addresses and associated **contact** information. This tool is designed to retrieve publicly available **data**, ensuring compliance with **LinkedIn**'s policies and legal regulations.

In addition to email addresses, it can gather names, job titles, company details, and other relevant profile information. The **extract**ed **data** is structured and organized for easy integration into your workflows, making it suitable for lead generation, marketing, or recruitment purposes.

With automated Linkedin email scraper capabilities, you can collect **data** efficiently and scale your operations without compromising accuracy or quality.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: dev.scraperengine@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Address | Extract verified email addresses from LinkedIn profiles. |
| Full Name | Retrieve the full name of the profile owner for personalized outreach. |
| Job Title | Capture the current job title listed on the LinkedIn profile. |
| Company Name | Extract the name of the company associated with the profile. |
| Location | Gather geographical location details from LinkedIn profiles. |
| Profile URL | Retrieve the direct URL to the LinkedIn profile for reference. |
| Industry | Identify the industry associated with the LinkedIn profile. |
| Connections Count | Extract the number of connections listed on the LinkedIn profile. |

### Key Features of **LinkedIn** Email Scraper

Here are the **standout features** that make the **LinkedIn** Email Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ **Automated** Linkedin email scraper for fast and accurate data extraction
- ⭐ Extract emails from Linkedin profiles securely and efficiently
- ⭐ Supports scraping of additional data like names job titles and company details
- ⭐ **Customizable** filters to target specific industries or locations
- ⭐ User-friendly interface for seamless operation and data management
- ⭐ **High** accuracy in extracting verified email addresses from public profiles
- ⭐ Scalable solution for large-scale Linkedin lead generation projects
- ⭐ Ensures compliance with **LinkedIn**s policies and legal guidelines
- ⭐ Provides structured data output for easy integration into workflows
- ⭐ **Advanced** algorithms to minimize data duplication and errors
- ⭐ **Regular** updates to maintain compatibility with **LinkedIn**s platform
- ⭐ **Comprehensive** documentation and support for troubleshooting

### How to use **LinkedIn** Email Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **LinkedIn** emails today:

1. ✅ **Sign up** for an account on the Linkedin Email Scraper platform
2. ✅ Log in to your account and navigate to the scraper dashboard
3. ✅ Enter your search criteria such as keywords industries or locations
4. ✅ **Select** the specific data types you want to extract from **LinkedIn** profiles
5. ✅ **Configure** filters to refine your search results and target specific profiles
6. ✅ **Start** the scraping process and monitor progress via the dashboard
7. ✅ Download the extracted data in your preferred format once the process is complete
8. ✅ **Integrate** the data into your CRM or other tools for further analysis or outreach
9. ✅ Adjust settings and filters for subsequent scraping tasks as needed
10. ✅ Refer to the documentation for troubleshooting and best practices

### Use Cases 🎯

Lead Generation
🎯 Extract emails from Linkedin profiles to build targeted lead lists
🎯 **Automate** Linkedin contact scraping for efficient outreach campaigns

Recruitment
🎯 Gather contact information of potential candidates from **LinkedIn**
🎯 **Use** Linkedin data extractor tools to streamline hiring processes

Market Research
🎯 **Analyze** industry trends by scraping Linkedin emails and profile data
🎯 Extract location and company details for regional market insights

Networking
🎯 Connect with professionals by extracting verified emails from **LinkedIn** profiles
🎯 Build connections using automated Linkedin email scraper tools

### Why choose us? 💎

Our Linkedin Email Scraper is the **best** Linkedin email scraping tool for businesses, recruiters, and marketers seeking accurate and **scalable** solutions. It is designed to automate email extraction from Linkedin profiles, saving time and resources while ensuring compliance with legal and ethical standards.

With **advanced** algorithms and customizable filters, you can target specific industries, locations, or keywords to refine your data collection process. The tool provides structured output, making it easy to integrate the data into your CRM or other systems.

We prioritize user experience with a simple interface and robust support to help you achieve your goals efficiently. Whether you need to scrape Linkedin emails for lead generation or recruitment, our tool delivers **reliable** results tailored to your needs.

### **LinkedIn** Email Scraper Scalability 📈

Linkedin Email Scraper offers a scalable solution for businesses and professionals looking to extract data from **LinkedIn** profiles. It is designed to handle both small-scale and **large-scale** scraping projects with ease, ensuring consistent accuracy and efficiency.

With **customizable** filters and **advanced** algorithms, you can target specific profiles or industries, making it suitable for diverse use cases. The tool supports batch processing, allowing you to extract data from thousands of profiles simultaneously without compromising quality.

Whether you are a startup or an enterprise, our automated Linkedin email scraper adapts to your requirements and grows with your needs. It is the ideal Linkedin lead generation tool for expanding your outreach and achieving your business objectives.

### **LinkedIn** Email Scraper Legal Guidelines ⚖️

**Yes**—scraping **LinkedIn** is **legal** as long as you follow **ethical** and **compliant** practices. The **LinkedIn** Email Scraper extracts only **publicly available** information from **public** **LinkedIn** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **LinkedIn**s terms of service when using the scraper
⚖️ **Only** extract publicly available data from **LinkedIn** profiles
⚖️ **Avoid** scraping private or restricted information from profiles
⚖️ **Use** the tool responsibly and respect user privacy on **LinkedIn**
⚖️ **Do not** use extracted data for spam or unsolicited communication
⚖️ Follow applicable data protection laws and regulations in your region
⚖️ **Obtain** consent if required before using extracted contact information
⚖️ Regularly review **LinkedIn**s policies to ensure ongoing compliance

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Linkedin Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "LinkedIn",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails to collect (default 20) |
| platform | Platform to scrape (LinkedIn) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "LinkedIn",
    "keyword": "Linkedin Email Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "email": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies LinkedIn as the source |
| keyword | Keyword that triggered the result (Linkedin Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct LinkedIn profile link |
| email | Extracted email address |

### 🔗 What other LinkedIn scraping tools are there?

If you want to scrape specific LinkedIn data, you can use any of the dedicated scrapers below for faster and more targeted results.\
Just enter profile URLs, company links, job search queries, or post URLs and start scraping instantly.

| [📄 LinkedIn Profile Post Scraper](https://apify.com/scraper-engine/linkedin-profile-post-scraper) | [⚡ LinkedIn Profile Scraper (Cheapest + Fastest)](https://apify.com/scraper-engine/linkedin-profile-scraper-cheapst-fastest) |
|---|---|
| [🏢 LinkedIn Company Profile Scraper](https://apify.com/scraper-engine/linkedin-company-profile-scraper) | [📝 LinkedIn Post Scraper](https://apify.com/scraper-engine/linkedin-post-scraper) |
| [📄 LinkedIn Company About Scraper](https://apify.com/scraper-engine/linkedin-company-about-scraper) | [👥 LinkedIn Company Employees Scraper](https://apify.com/scraper-engine/linkedin-company-employees-scraper) |
| [💼 LinkedIn Search Jobs Scraper](https://apify.com/scraper-engine/linkedin-search-jobs-scraper) | [📢 LinkedIn Ads Scraper](https://apify.com/scraper-engine/linkedin-ads-scraper) |
| [📋 LinkedIn Jobs Scraper](https://apify.com/scraper-engine/linkedin-jobs-scraper) | [📰 LinkedIn Company Post Scraper](https://apify.com/scraper-engine/linkedin-company-post-scraper) |
| [📧 LinkedIn Profile Email Scraper](https://apify.com/scraper-engine/linkedin-profile-email-scraper) | [📞 LinkedIn Phone Number Scraper](https://apify.com/scraper-engine/linkedin-phone-number-scraper) |
| [☎️ LinkedIn Profile Phone Number Scraper](https://apify.com/scraper-engine/linkedin-profile-phone-number-scraper) | [🔓 LinkedIn Open Profile Status](https://apify.com/scraper-engine/scraper-engine/linkedin-open-profile-status) |
| [👍 LinkedIn Post Reactions Scraper](https://apify.com/scraper-engine/linkedin-post-reactions-scraper) | [📊 LinkedIn Profile and Company Posts Scraper](https://apify.com/scraper-engine/linkedin-profile-and-company-posts-scraper) |

### FAQ ❓

#### What is Linkedin **Email Scraper**?

Linkedin Email Scraper is a tool designed to extract email addresses and other data from LinkedIn profiles efficiently.

#### Is it **legal** to scrape Linkedin emails?

**Yes**, as long as you extract **publicly available** data and comply with LinkedIn's terms of service and applicable laws.

#### Can I use this tool for **lead generation**?

**Yes**, Linkedin Email Scraper is ideal for building targeted lead lists by extracting contact information from LinkedIn profiles.

#### What data can I **extract** using this tool?

You can extract **emails**, names, job titles, company names, locations, profile URLs, industries, and connections count.

#### Is the **extract**ed data accurate?

**Yes**, the tool uses advanced algorithms to ensure high accuracy in data extraction.

#### How do I integrate the **extract**ed data into my **CRM**?

You can download the data in structured formats compatible with most CRM systems for **seamless** integration.

#### Does the tool comply with LinkedIn's policies?

**Yes**, it is designed to extract data responsibly and in **compliance** with LinkedIn's terms of service.

#### Can I scrape **private** LinkedIn profiles?

**No**, the tool only extracts **publicly available** data from LinkedIn profiles.

#### Is the tool scalable for large projects?

**Yes**, Linkedin Email Scraper is built to handle both small and large-scale data extraction tasks efficiently.

The tool supports multiple formats such as **CSV**, Excel, and **JSON** for data export.

#### Can I use the tool for market research?

**Yes**, it is suitable for analyzing industry trends and extracting relevant LinkedIn data for research purposes.

# 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("scraper-engine/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("scraper-engine/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 scraper-engine/linkedin-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linkedin Email Scraper",
        "description": "LinkedIn Email Scraper extracts publicly available email addresses from LinkedIn profiles and linked websites. Build targeted contact lists by role, industry, or company. Ideal for sales teams running outbound campaigns.",
        "version": "0.1",
        "x-build-id": "kfin78s6M9bHfUJlT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~linkedin-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-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/scraper-engine~linkedin-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-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/scraper-engine~linkedin-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```