# Linkedin B2B Email Scraper (`scraperx/linkedin-b2b-email-scraper`) Actor

🚀 LinkedIn B2B Email Scraper helps you extract business emails from LinkedIn profiles and company pages quickly. Ideal for B2B lead gen, sales outreach, and market research—save time, boost targeting, and improve conversion. 📈📩

- **URL**: https://apify.com/scraperx/linkedin-b2b-email-scraper.md
- **Developed by:** [ScraperX](https://apify.com/scraperx) (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 $3.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### **LinkedIn** Email Scraper 📱

Linkedin B2B Email Scraper allows users to **extract** a variety of **data** from **LinkedIn** profiles. This includes verified email addresses, job titles, company names, and location details, enabling precise targeting for B2B campaigns.

The tool also captures profile URLs and industry information, which are crucial for segmenting leads effectively. Users can gather **data** in bulk, making it easier to build comprehensive **contact** lists for email marketing or recruitment purposes.

Linkedin email **extract**or ensures the accuracy of the **extract**ed **data**, reducing the risk of outdated or incorrect information. With automated email scraping, businesses can focus on outreach and engagement while the tool handles **data** collection efficiently.

Linkedin B2B Email Scraper is an advanced tool designed to extract verified email addresses and contact information from LinkedIn profiles. It enables businesses to streamline their lead generation and outreach processes efficiently.

By utilizing Linkedin B2B Email Scraper, users can automate the extraction of essential contact data for B2B prospecting. This tool is ideal for building targeted email lists and enhancing lead generation strategies.

LinkedIn is a powerful platform for networking and business connections, and Linkedin B2B Email Scraper helps users maximize its potential. With automated email scraping and data extraction, businesses can save time and focus on outreach efforts.

### 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 for outreach purposes. |
| Job Title | Capture the job titles of LinkedIn users to identify key decision-makers. |
| Company Name | Retrieve company names to understand organizational affiliations. |
| Location | Extract location details to target leads based on geographic regions. |
| Profile URL | Gather LinkedIn profile URLs for direct access to user profiles. |
| Industry | Identify the industry of LinkedIn users for better segmentation. |
| Connections Count | Retrieve the number of connections to gauge network size. |
| Skills | Extract listed skills to understand user expertise and qualifications. |

### 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** email scraping for **LinkedIn** profiles to save time and effort
- ⭐ **Accurate** data extraction with minimal risk of outdated information
- ⭐ Bulk data collection for building comprehensive contact lists
- ⭐ **Customizable** filters to target specific industries or job titles
- ⭐ **Integration** with CRM tools for seamless lead management
- ⭐ User-friendly interface for easy navigation and operation
- ⭐ Supports data export in multiple formats like CSV and Excel
- ⭐ Compliance with **LinkedIn**s data usage policies and privacy standards
- ⭐ Real-time data extraction to ensure up-to-date information
- ⭐ **Advanced** algorithms to identify and verify email addresses

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

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

1. ✅ **Sign up** for the Linkedin B2B Email Scraper and **log in** to your account
2. ✅ Set up your **LinkedIn** integration by providing access credentials
3. ✅ Define your search criteria such as job titles industries or locations
4. ✅ **Start** the scraping process by clicking the Extract Data button
5. ✅ Monitor the progress of data extraction through the dashboard
6. ✅ Once completed review the extracted data for accuracy and completeness
7. ✅ **Export** the data to your preferred format such as CSV or Excel
8. ✅ **Integrate** the data with your CRM or email marketing tool for outreach

### Use Cases 🎯

B2B Lead Generation
🎯 Build targeted email lists for B2B campaigns
🎯 **Identify** decision-makers in specific industries or companies
🎯 Enhance prospecting efforts with verified contact information

Recruitment
🎯 **Find** potential candidates based on job titles and skills
🎯 Extract contact details for outreach and recruitment purposes
🎯 Target professionals in specific geographic locations

Email Marketing
🎯 Create personalized email campaigns using accurate data
🎯 Segment leads by industry location or company size
🎯 Improve email deliverability with verified email addresses

Market Research
🎯 **Analyze** **LinkedIn** profiles to understand industry trends
🎯 Gather data on competitors and their networks
🎯 **Identify** potential partners or collaborators for business growth

### Why choose us? 💎

Linkedin B2B Email Scraper offers unparalleled accuracy and efficiency in extracting contact data from **LinkedIn** profiles. Our tool is designed to cater to businesses of all sizes, whether you're a startup or an established enterprise.

With features like automated email scraping and customizable filters, users can target leads with precision. We prioritize compliance with **LinkedIn**'s data usage policies to ensure ethical data extraction.

Our software integrates seamlessly with CRM tools, enabling smooth lead management and outreach. By choosing Linkedin B2B Email Scraper, businesses can save time, reduce manual effort, and focus on building meaningful connections.

Our dedicated support team is available to assist users and ensure a seamless experience. Whether you're looking to scale your B2B campaigns or enhance recruitment efforts, our tool is the perfect solution.

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

Linkedin B2B Email Scraper is designed to handle **large-scale** data extraction **efficient**ly. Whether you're targeting hundreds or thousands of **LinkedIn** profiles, our tool ensures consistent performance.

The software supports bulk data collection, allowing businesses to build **extensive** contact lists quickly. With **advanced** algorithms, users can extract data in real-time without compromising accuracy.

Our scalable infrastructure accommodates growing business needs, making it ideal for enterprises looking to expand their outreach. Linkedin B2B Email Scraper integrates with CRM tools to streamline lead management, regardless of the volume of data.

By automating the scraping process, businesses can focus on scaling their campaigns while the tool handles data extraction **seamless**ly.

### **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
⚖️ **Do not** use extracted data for unsolicited or spam email campaigns
⚖️ Verify the accuracy of extracted data before using it for outreach
⚖️ Respect user privacy and avoid extracting sensitive information without consent
⚖️ **Use** the tool ethically and avoid scraping profiles that are not relevant to your business needs
⚖️ Follow data protection laws like GDPR and CCPA when handling extracted data
⚖️ **Do not** resell or distribute extracted data without proper authorization
⚖️ Regularly review **LinkedIn**s policies to ensure continued compliance

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Linkedin B2B 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 B2B 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 B2B Email Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct LinkedIn profile link |
| email | Extracted email address |

### FAQ ❓

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

Linkedin B2B Email Scraper is a tool designed to extract verified email addresses and contact information from LinkedIn profiles for B2B prospecting.

#### How does Linkedin B2B **Email Scraper** work?

The tool automates the process of extracting data from LinkedIn profiles based on user-defined search criteria.

#### Is the data **extract**ion process compliant with LinkedIn's policies?

**Yes**, Linkedin B2B Email Scraper is designed to comply with LinkedIn's terms of service and data usage policies.

#### Can I **export** the **extract**ed data?

**Yes**, users can export data in formats like **CSV** or Excel for further use.

#### Does the tool verify email addresses?

**Yes**, Linkedin B2B Email Scraper uses advanced algorithms to verify the accuracy of extracted email addresses.

#### Is Linkedin B2B **Email Scraper** suitable for small businesses?

**Yes**, the tool is designed to cater to **businesses** of all sizes, including startups and small enterprises.

#### Can I integrate the tool with my **CRM**?

**Yes**, Linkedin B2B Email Scraper supports integration with popular CRM tools for streamlined lead management.

#### Is the tool easy to use?

**Yes**, Linkedin B2B Email Scraper features a **user-friendly** interface for easy navigation and operation.

#### Does the tool support bulk data **extract**ion?

**Yes**, Linkedin B2B Email Scraper can handle large-scale data extraction efficiently.

#### Are there any restrictions on the type of profiles I can scrape?

Users should only scrape profiles relevant to their business needs and comply with LinkedIn's policies.

#### What industries can I target with this tool?

Linkedin B2B Email Scraper allows users to target profiles across various industries based on search criteria.

#### Is the tool **secure**?

**Yes**, Linkedin B2B Email Scraper prioritizes data security and user privacy throughout the extraction process.

#### How often is the data updated?

The tool extracts data in real-time to ensure users receive up-to-date information.

#### Can I customize the search filters?

**Yes**, users can define search criteria like job titles, industries, or locations for targeted data extraction.

#### What support options are available?

Our **dedicated support** team is available to assist users with any issues or questions regarding the tool.

# Actor input Schema

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

List of keywords to search for on Linkedin (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Linkedin profiles/posts containing these keywords and extract email addresses.

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

Select platform.

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

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

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

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

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

Maximum number of emails to collect per keyword (default: 20).

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

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## 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-b2b-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-b2b-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-b2b-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linkedin B2B Email Scraper",
        "description": "🚀 LinkedIn B2B Email Scraper helps you extract business emails from LinkedIn profiles and company pages quickly. Ideal for B2B lead gen, sales outreach, and market research—save time, boost targeting, and improve conversion. 📈📩",
        "version": "0.1",
        "x-build-id": "yqMUhioa37kltio5L"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperx~linkedin-b2b-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperx-linkedin-b2b-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-b2b-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperx-linkedin-b2b-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-b2b-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperx-linkedin-b2b-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 keywords to search for on Linkedin (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Linkedin profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Linkedin"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Linkedin"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```