# Linkedin B2B Lead Scraper (`scrapapi/linkedin-b2b-lead-scraper`) Actor

- **URL**: https://apify.com/scrapapi/linkedin-b2b-lead-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Lead generation, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### **LinkedIn** Lead Scraper 📱

Linkedin B2B Lead Scraper allows users to **extract** essential **contact** information from **LinkedIn** profiles. It gathers **data** such as lead addresses, names, job titles, and company details, enabling businesses to build targeted outreach lists.

This **LinkedIn** **contact** **extract**or ensures the **data** is accurate and relevant, making it a valuable tool for B2B lead generation. The **extract**ed **data** is structured and ready for integration into CRM systems or lead marketing platforms.

By using this **LinkedIn** **data** scraping software, businesses can save time and focus on connecting with the right prospects. The tool is designed to handle large-scale **data** **extract**ion while maintaining compliance with ethical guidelines.

Linkedin B2B Lead Scraper is a powerful tool designed to automate the process of extracting business leads from LinkedIn profiles. It simplifies B2B lead generation by providing accurate and verified lead data for outreach campaigns.

With the increasing demand for precise B2B lead extraction, this LinkedIn lead finder ensures you can gather contact details efficiently. It is a reliable LinkedIn lead generation tool for businesses looking to scale their prospecting efforts.

Automated LinkedIn lead scraping saves time and effort while ensuring compliance with ethical data usage practices. This lead scraping tool for LinkedIn is ideal for businesses aiming to streamline their outreach strategies.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead Address | Extracts verified business lead addresses from LinkedIn profiles for B2B outreach. |
| Full Name | Captures the full name of LinkedIn users for personalized communication. |
| Job Title | Retrieves the current job title of LinkedIn users to target specific roles. |
| Company Name | Identifies the company associated with the LinkedIn profile for better segmentation. |
| Location | Extracts the geographical location of the user for regional targeting. |
| LinkedIn Profile URL | Provides the direct LinkedIn profile link for further research or connection. |
| Industry | Gathers industry details to categorize prospects by sector. |
| Profile Summary | Fetches the summary section for additional insights into the user's expertise. |

### Key Features of **LinkedIn** Lead Scraper

Here are the **standout features** that make the **LinkedIn** Lead Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ **Automated** extraction of business leads from **LinkedIn** profiles
- ⭐ **Accurate** and verified data for effective B2B lead generation
- ⭐ Supports bulk data scraping for large-scale prospecting campaigns
- ⭐ **Customizable** filters to target specific industries roles or locations
- ⭐ **Integration**-ready data compatible with CRM and lead marketing tools
- ⭐ User-friendly interface with straightforward setup and operation
- ⭐ Ensures compliance with ethical data usage and privacy regulations
- ⭐ **High**-speed data extraction with minimal manual effort required
- ⭐ **Regular** updates to maintain compatibility with **LinkedIn**s platform
- ⭐ Detailed reporting and export options for seamless data management

### How to use **LinkedIn** Lead Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **LinkedIn** leads today:

1. ✅ **Sign up** for the Linkedin B2B Lead Scraper and **log in** to your account
2. ✅ Connect your **LinkedIn** account to enable data extraction capabilities
3. ✅ Set up your extraction parameters such as job title industry or location
4. ✅ **Start** the scraping process to gather targeted **LinkedIn** profile data
5. ✅ Monitor the progress of the scraping process through the dashboard
6. ✅ Download the extracted data in your preferred format such as CSV or Excel
7. ✅ Import the data into your CRM or lead marketing platform for outreach
8. ✅ **Review** and verify the extracted data to ensure accuracy and relevance
9. ✅ Use the data for personalized B2B lead campaigns or prospecting
10. ✅ Repeat the process as needed to update or expand your contact database

### Use Cases 🎯

B2B Lead Generation
🎯 Build targeted lead lists for outreach campaigns
🎯 **Identify** decision-makers in specific industries or companies

Sales Prospecting
🎯 Streamline the process of finding potential clients on **LinkedIn**
🎯 Enhance sales strategies with accurate contact information

Recruitment and Hiring
🎯 **Identify** and connect with top talent in your industry
🎯 Gather contact details for potential candidates from **LinkedIn** profiles

Market Research
🎯 **Analyze** **LinkedIn** data to understand industry trends
🎯 Segment users by job title industry or location for insights

Networking and Partnerships
🎯 **Find** and connect with professionals for collaboration opportunities
🎯 Build a network of industry contacts through **LinkedIn** data

### Why choose us? 💎

Linkedin B2B Lead Scraper is designed to meet the growing demand for efficient and accurate B2B lead extraction. Our tool offers a **user-friendly** interface that simplifies the process of gathering contact information from **LinkedIn** profiles.

With customizable filters and bulk scraping capabilities, it is an ideal **LinkedIn** lead generation tool for businesses of all sizes. We prioritize data accuracy and compliance with privacy regulations, ensuring that the extracted information is both **reliable** and ethically sourced.

Our automated **LinkedIn** lead scraping solution saves time and resources, allowing users to focus on building meaningful connections. Whether you are a marketer, recruiter, or sales professional, our tool provides the features you need to succeed in your outreach efforts.

Trust us to deliver a comprehensive and **scalable** **LinkedIn** lead finder that meets your business needs.

### **LinkedIn** Lead Scraper Scalability 📈

Linkedin B2B Lead Scraper is built to handle the demands of businesses of all sizes, from startups to enterprises. Our tool supports bulk data extraction, enabling users to gather thousands of **LinkedIn** profiles' contact information in a single session.

With **advanced** filtering options, you can target specific industries, roles, or locations without compromising on speed or accuracy. The software is optimized for high performance, ensuring that **large-scale** scraping tasks are completed **efficient**ly.

Whether you are conducting a small campaign or a **large-scale** prospecting effort, our **LinkedIn** data scraping software adapts to your requirements. This scalability makes it a valuable asset for growing businesses looking to expand their outreach efforts.

### **LinkedIn** Lead Scraper Legal Guidelines ⚖️

**Yes**—scraping **LinkedIn** is **legal** as long as you follow **ethical** and **compliant** practices. The **LinkedIn** Lead 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 information from **LinkedIn** profiles
⚖️ **Do not** use the tool for unauthorized or unethical data collection
⚖️ Respect user privacy and avoid scraping sensitive personal information
⚖️ **Use** the extracted data solely for legitimate business purposes
⚖️ Verify the accuracy of the data before using it for outreach campaigns
⚖️ **Adhere** to applicable data protection laws such as GDPR or CCPA
⚖️ **Avoid** reselling or redistributing the extracted data without consent

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Linkedin B2B Lead Scraper"],
  "country": "Global",
  "maxLeadNumbers": 20,
  "platform": "LinkedIn",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxLeadNumbers | Maximum leads 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 Lead 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",
    "lead": "before@gmail.com"
  }
]
```

### Output Table

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

### FAQ ❓

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

It is a tool designed to extract business lead addresses and other contact information from LinkedIn profiles for B2B lead generation.

#### How does this LinkedIn lead finder work?

The tool automates the process of gathering **publicly available** contact details from LinkedIn profiles based on your specified criteria.

#### Is this LinkedIn **lead generation** tool compliant with privacy laws?

**Yes**, it is designed to ensure **compliance** with data protection laws like GDPR and CCPA when used responsibly.

#### Can I use this tool for bulk data scraping?

**Yes**, the tool supports bulk data extraction, allowing you to gather **large volumes** of LinkedIn profile data efficiently.

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

You can extract lead addresses, names, job titles, company names, locations, LinkedIn profile URLs, industries, and profile summaries.

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

The tool ensures high accuracy by verifying and structuring the extracted data for reliable use.

#### Can I integrate the **extract**ed data with my **CRM**?

**Yes**, the data can be exported in formats compatible with most CRM and lead marketing platforms.

#### Does this tool require technical expertise to use?

**No**, it features a **user-friendly** interface that makes it accessible to users with minimal technical knowledge.

#### How frequently is the software updated?

The software is regularly updated to ensure compatibility with LinkedIn's platform and maintain optimal performance.

#### Is there a **limit** to the number of profiles I can scrape?

The tool supports scalable scraping, but limits may depend on your subscription plan and LinkedIn's usage policies.

#### Can I target **specific** industries or job titles?

**Yes**, the tool allows you to apply filters to target specific industries, job titles, or locations.

#### Is this tool suitable for small businesses?

**Yes**, it is designed to cater to **businesses** of all sizes, including small and medium enterprises.

#### What is the pricing for Linkedin B2B **Lead Scraper**?

Pricing details can be found on our website, and we offer various plans to suit different business needs.

#### Can I use this tool for recruiting purposes?

**Yes**, it is an excellent resource for recruiters to gather contact details of potential candidates.

#### Is there **customer support** available?

**Yes**, our team provides **dedicated support** to assist with any questions or issues you may encounter.

# 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("scrapapi/linkedin-b2b-lead-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("scrapapi/linkedin-b2b-lead-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 scrapapi/linkedin-b2b-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linkedin B2B Lead Scraper",
        "version": "0.1",
        "x-build-id": "0GA8bpbbmOCx5lKwe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~linkedin-b2b-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-linkedin-b2b-lead-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/scrapapi~linkedin-b2b-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-linkedin-b2b-lead-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/scrapapi~linkedin-b2b-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-linkedin-b2b-lead-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
