# Linkedin Profile Lead Scraper (`scraper-engine/linkedin-profile-lead-scraper`) Actor

Extract professional leads from LinkedIn using the LinkedIn Profile Lead Scraper. Collect names, job titles, companies, profile links, locations, and other public profile details automatically. Ideal for B2B lead generation, recruitment, and sales prospecting.

- **URL**: https://apify.com/scraper-engine/linkedin-profile-lead-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Automation, Jobs
- **Stats:** 5 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### **LinkedIn** Lead Scraper 📱

Linkedin Profile Lead Scraper is designed to **extract** essential **contact** information from **LinkedIn** profiles with precision. It focuses on gathering verified lead addresses, ensuring users receive accurate **data** for their outreach efforts.

The tool also **extract**s supplementary details like names, job titles, and company information to provide a comprehensive **data**set. By using this Linkedin lead finder software, users can streamline their lead generation process and save valuable time.

The **extract**ed **data** is formatted for easy integration into CRM systems and marketing platforms. This automated Linkedin lead scraping tool is perfect for professionals seeking to enhance their networking and business development strategies.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: dev.scraperengine@gmail.com *
  
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead Address | Extract verified lead addresses from LinkedIn profiles for accurate contact information. |
| Full Name | Retrieve the full name of LinkedIn profile owners for personalized outreach. |
| Job Title | Gather job titles to understand the professional roles of LinkedIn users. |
| Company Name | Extract company names to identify the organizations associated with LinkedIn profiles. |
| Location | Collect location details to target users based on geographical preferences. |
| Profile URL | Retrieve LinkedIn profile URLs for direct access to user profiles. |
| Industry | Extract industry information to categorize LinkedIn profiles by professional sectors. |
| Connections Count | Gather the number of connections to assess the networking potential of profiles. |

### 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 verified lead addresses from **LinkedIn** profiles
- ⭐ User-friendly interface for seamless operation and data collection
- ⭐ Supports bulk scraping to process multiple profiles simultaneously
- ⭐ Delivers accurate and formatted data for easy integration into CRM systems
- ⭐ Complies with ethical and legal standards for **LinkedIn** data extraction
- ⭐ Offers advanced filtering options to target specific industries or locations
- ⭐ Provides real-time data updates to ensure the latest contact information
- ⭐ Optimized for high-speed data extraction without compromising accuracy
- ⭐ Includes detailed analytics and reporting for extracted data sets
- ⭐ Compatible with various operating systems and web browsers

### 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 Profile Lead Scraper tool on the official website
2. ✅ Install the software or access the online platform based on your preference
3. ✅ Log in using your credentials to access the scraper dashboard
4. ✅ Enter the **LinkedIn** profile URLs or keywords for targeted data extraction
5. ✅ **Configure** advanced filters such as location industry or job titles if needed
6. ✅ **Start** the scraping process and monitor progress through the dashboard
7. ✅ Download the extracted data in your preferred format such as CSV or Excel
8. ✅ **Integrate** the data into your CRM or marketing tools for further use

### Use Cases 🎯

Lead Generation
🎯 Build targeted lead lists from **LinkedIn** profiles for outreach campaigns
🎯 Enhance B2B lead generation efforts with verified contact information

Recruitment
🎯 **Identify** potential candidates by extracting leads and job titles
🎯 Streamline recruitment processes with automated Linkedin contact scraper tools

Networking
🎯 Expand your professional network by collecting lead addresses
🎯 Connect with industry leaders using accurate **LinkedIn** data

Market Research
🎯 **Analyze** **LinkedIn** profiles to understand industry trends
🎯 Extract data for competitor analysis and business strategy development

### Why choose us? 💎

Linkedin Profile Lead Scraper stands out as the **best** Linkedin lead scraper tool due to its unmatched efficiency and accuracy. Our software is designed to cater to professionals seeking **reliable** lead extraction without manual effort.

With **advanced** automation, it ensures compliance with **LinkedIn**'s guidelines while delivering high-quality results. Our tool supports bulk scraping, enabling users to process multiple profiles simultaneously and save valuable time.

It offers customizable filters to target specific industries, locations, or job roles, making it ideal for lead generation and recruitment. The extracted data is formatted for easy integration into CRM systems, enhancing workflow efficiency.

Our commitment to ethical practices and user satisfaction ensures a seamless experience for all users. Choose Linkedin Profile Lead Scraper to unlock the full potential of **LinkedIn** for your business growth and networking needs.

### **LinkedIn** Lead Scraper Scalability 📈

Linkedin Profile Lead Scraper is built to handle **large-scale** data extraction tasks with ease. Whether you need to scrape hundreds or thousands of **LinkedIn** profiles, our tool ensures consistent performance and accuracy.

It supports bulk processing, allowing users to extract data from multiple profiles simultaneously without compromising speed. The software is optimized for high-speed operations, ensuring timely delivery of results for businesses of all sizes.

With **advanced** filtering options, users can target specific profiles based on industries, locations, or job roles, making it highly adaptable to diverse needs. Our scraper is compatible with various operating systems and integrates **seamless**ly with CRM systems, ensuring scalability for growing businesses.

Choose Linkedin Profile Lead Scraper to meet your expanding data extraction requirements **efficient**ly and reliably.

### **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
⚖️ **Do not** use the tool to extract data from private or restricted profiles
⚖️ **Avoid** sharing extracted data with unauthorized third parties
⚖️ **Use** the scraper for legitimate purposes such as lead generation or networking
⚖️ Respect user privacy and refrain from extracting sensitive information
⚖️ Follow applicable data protection laws and regulations in your region
⚖️ **Do not** misuse the tool for spamming or unsolicited lead campaigns
⚖️ Regularly review **LinkedIn**s policies to ensure continued compliance

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Linkedin Profile 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 Profile 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 Profile 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 Profile **Lead Scraper**?

Linkedin Profile Lead Scraper is a tool designed to extract verified lead addresses and other contact information from LinkedIn profiles.

#### Is the scraper compliant with LinkedIn's policies?

**Yes**, the tool is designed to comply with LinkedIn's terms of service and ethical standards.

#### Can I use the scraper for bulk data **extract**ion?

**Yes**, the tool supports bulk scraping to process multiple LinkedIn profiles simultaneously.

#### What data types can be **extract**ed using the scraper?

The scraper extracts lead addresses, names, job titles, company names, locations, profile URLs, industries, and connection counts.

#### Is the **extract**ed data formatted for **CRM** integration?

**Yes**, the data is delivered in formats like **CSV** or Excel for easy integration into CRM systems.

#### Does the tool offer filtering options?

**Yes**, users can apply filters such as location, industry, or job titles to target specific profiles.

#### Is the scraper compatible with all operating systems?

**Yes**, the tool is compatible with various operating systems and web browsers.

#### How accurate is the **extract**ed lead data?

The tool ensures high accuracy by extracting verified lead addresses from LinkedIn profiles.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linkedin Profile Lead Scraper",
        "description": "Extract professional leads from LinkedIn using the LinkedIn Profile Lead Scraper. Collect names, job titles, companies, profile links, locations, and other public profile details automatically. Ideal for B2B lead generation, recruitment, and sales prospecting.",
        "version": "0.1",
        "x-build-id": "LABokfaNT0dh29QqS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~linkedin-profile-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-linkedin-profile-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/scraper-engine~linkedin-profile-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-linkedin-profile-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/scraper-engine~linkedin-profile-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-linkedin-profile-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
