# Mass Linkedin Leads Generator (`scrapedrift/mass-linkedin-leads-generator`) Actor

🚀 Mass LinkedIn Leads Generator helps you bulk-extract high-quality lead data from LinkedIn. Find targeted prospects, boost outreach, and accelerate B2B sales & recruiting—fast, reliable, and scalable. 📈💼

- **URL**: https://apify.com/scrapedrift/mass-linkedin-leads-generator.md
- **Developed by:** [ScrapeDrift](https://apify.com/scrapedrift) (community)
- **Categories:** Lead generation, Automation, Jobs
- **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 Leads Generator - B2B & B2C Email Finder ⚡

Finding the right LinkedIn leads and turning them into outreach-ready contacts is usually the slow part of prospecting. **LinkedIn Leads Generator - B2B & B2C Email Finder** automatically scrapes publicly available LinkedIn profile matches from your keywords and extracts email addresses when present. It’s a practical LinkedIn email finder tool for B2B LinkedIn lead generation and B2C email scraping for leads. Built for sales teams, marketers, recruiters, and researchers who need prospecting leads with email at scale—without doing everything manually. In one run, you can collect up to hundreds of leads across multiple keywords and export them immediately from the dataset.

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
{
  "keyword": "marketing manager",
  "username": "jane-smith",
  "userLink": "https://www.linkedin.com/in/jane-smith/",
  "emails": [
    "jane.smith@company.com",
    "jsmith@gmail.com"
  ],
  "status": "ok",
  "error_message": null
}
````

**Output fields are written to the dataset view titled “Scraped Leads”.** Export your full dataset as JSON, CSV, or Excel from the Apify dashboard.

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | The keyword that produced this LinkedIn lead (useful for segmenting your outreach). |
| `username` | string | The LinkedIn profile name extracted from the profile URL (handy for matching/deduping). |
| `userLink` | string | The profile URL you can open to verify context before outreach. |
| `emails` | array | Email addresses extracted from the publicly available profile search description text. |
| `status` | string | Indicates whether the record was processed successfully (e.g., `ok`). |
| `error_message` | string | Explains what went wrong when something fails; `null` when there’s no error. |

***

### Setting It Up

Drop this into your `input.json` and you're ready to go:

```json
{
  "keywords": ["software engineer", "marketing manager"],
  "country": "United States",
  "maxLeadsPerKeyword": 20,
  "scrapeLeadsWithEmail": false
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | List of keywords to search for LinkedIn profiles. Each keyword is processed separately, so you can target different roles or intents. |
| `country` | ⬜ | Filters results by country. Leave it empty for worldwide results; by default it uses `United States`. |
| `maxLeadsPerKeyword` | ⬜ | Maximum number of leads to collect for each keyword (from 1 to 500). Default is 20. |
| `scrapeLeadsWithEmail` | ⬜ | If `true`, the actor operates in email-focused mode and filters profiles to those that have emails found from publicly available sources. If `false`, it collects all matching profiles regardless of whether emails are detected. Default is `false`. |

***

### What It Does

LinkedIn Leads Generator - B2B & B2C Email Finder scrapes matching LinkedIn profiles based on your keywords and produces a dataset of leads with contact emails (when available).

#### Keyword-driven LinkedIn lead discovery

You provide job-title or role keywords in `keywords`, and the actor processes each keyword to gather leads. This makes it straightforward to run LinkedIn lead database style workflows by department, seniority, or target persona.

#### Flexible country targeting

Use `country` to focus results on a specific geography. If you leave it empty, you’ll get worldwide results, which is helpful when you’re building prospecting leads across regions.

#### Email mode for outreach-ready leads

When you enable `scrapeLeadsWithEmail`, the actor focuses on finding profiles that have emails and filters out leads without detected emails. This is a good fit for LinkedIn contact info finder workflows where email is the output you care about most—like LinkedIn prospecting email outreach.

#### Clean, consistent dataset output

For each output record, you get `keyword`, `username`, `userLink`, and `emails`. That means your LinkedIn leads generator with email output is structured and ready to plug into outreach tools or spreadsheets.

#### Works reliably with retries and fallbacks

The actor includes retry logic when scraping pages and continues operating as it searches through results. If it can’t access results for a given page, it uses fallback behavior so the run can still complete and produce what it can.

Overall, LinkedIn Leads Generator - B2B & B2C Email Finder helps you go from role keywords to structured lead records with emails—faster than manual LinkedIn email finder tool workflows.

***

### Why LinkedIn Leads Generator - B2B & B2C Email Finder?

There are plenty of ways to pull data from LinkedIn—here’s why LinkedIn Leads Generator - B2B & B2C Email Finder stands out.

#### Built for real outreach workflows

The output is designed around prospecting: you get `userLink` for verification and `emails` for direct follow-up. That makes it a practical LinkedIn to email finder when you want structured results for LinkedIn prospecting email outreach.

#### Email filtering when you need it

You can choose between collecting all matching profiles (`scrapeLeadsWithEmail: false`) or restricting to leads with detected emails (`scrapeLeadsWithEmail: true`). This flexibility supports both “build a long list” and “build an outreach list” modes in one tool.

#### Resilient scraping behavior

The actor uses retry logic and handles empty pages to keep searches moving. It’s built to continue producing usable results even when some pages don’t return data, which helps when running multiple keywords or larger caps via `maxLeadsPerKeyword`.

***

### Real-World Use Cases

Here's how different teams put LinkedIn Leads Generator - B2B & B2C Email Finder to work:

**Sales Teams**\
Your SDR team starts with a list of target roles like “marketing manager” and “sales director,” then needs contact emails to start sequences. They run LinkedIn Leads Generator - B2B & B2C Email Finder with `scrapeLeadsWithEmail: true` so the dataset includes leads with emails, then export to continue prospecting without copy-paste work.

**Marketing Agencies**\
A campaign lead agency needs to build a prospecting lead tool dataset for multiple clients in parallel. They run keyword-based LinkedIn data mining for leads using different `keywords` per niche, set a `country` when needed, and export clean records for each keyword segment.

**Recruiters & Talent Sourcing Researchers**\
While sourcing candidates, recruiters often want both profile context and a way to contact. With the dataset’s `userLink` and `emails`, they can enrich candidate outreach workflows by combining role keyword searches with email-ready contact fields.

**B2C Lead Generation & Partnerships**\
If you’re building B2C email scraper style partner outreach lists, you can use broad consumer-facing role keywords and switch on email mode to focus on detected emails. The result is a structured contact list that supports faster partner outreach from LinkedIn leads generator with email.

**Automation & Data Engineering**\
A developer or analyst triggers runs and feeds the dataset into downstream systems for deduping, enrichment, and CRM import. Because output records are consistent (`keyword`, `username`, `userLink`, `emails`), it’s easier to integrate LinkedIn contact info finder results into a pipeline.

***

### How to Run It

No code required. Here's how to get your first results in under 5 minutes:

1. **Open the actor on Apify** — go to the actor page and click **Run**: https://console.apify.com
2. **Enter your inputs** — set `keywords` (required), and optionally `country`, `maxLeadsPerKeyword`, and `scrapeLeadsWithEmail`.
3. **Configure proxy settings briefly** — use the built-in proxy support for reliable scraping (you can keep defaults if you’re unsure).
4. **Start the run and watch the live log** — monitor progress by keyword and see how many leads are collected.
5. **Open the Dataset tab to see live results** — the dataset view “Scraped Leads” shows `keyword`, `username`, `userLink`, and `emails`.
6. **Export in your preferred format** — download as JSON, CSV, or Excel from the dataset.
7. **Iterate on your inputs** — adjust `maxLeadsPerKeyword` or toggle `scrapeLeadsWithEmail` to switch between list-building and outreach-only datasets.

The whole setup takes under 5 minutes — results start appearing within seconds of launch.

***

### Export & Integration Options

Once your data is collected, LinkedIn Leads Generator - B2B & B2C Email Finder fits directly into your existing workflow.

You can export your dataset as **JSON, CSV, or Excel** from the Apify dashboard (dataset view: “Scraped Leads”). This makes it easy to import into CRMs, spreadsheets, and BI tools.

You can also integrate the actor into automation using **Apify API** workflows, no-code automation platforms like **Zapier** or **Make**, and run it on a schedule for ongoing lead generation. For more details, refer to Apify documentation for dataset export and API usage.

***

### Pricing

LinkedIn Leads Generator - B2B & B2C Email Finder runs on Apify, which includes a **free tier** — no credit card needed to start. You can begin with a few real test runs to validate that the keywords, `country`, and `scrapeLeadsWithEmail` mode return the email quality you need.

For larger workloads, you’ll use Apify’s pay-as-you-go model billed per Actor compute unit (CU) without locking into a monthly scrape fee. Start free at https://apify.com — scale up when you need.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Rate-limit resilience | Built-in retry behavior and search progression across pages |
| Missing/empty pages | Stops a keyword search after consecutive empty pages in each search mode |
| Email filtering option | `scrapeLeadsWithEmail` lets you focus only on leads with detected emails |
| Partial results | Leads are written as the run progresses via dataset output |
| Result caps | Controlled by `maxLeadsPerKeyword` per keyword |

**Limitations:** This actor works only with publicly available information and extracts emails from the description text found in publicly accessible sources. It cannot guarantee that every profile will have an email available, so the `emails` array may be empty depending on the mode and the source content. For private or login-gated profiles, results won’t be available.

For enterprise-scale needs or custom configurations, reach out and we'll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes, Apify offers a free tier with usage credits. This is enough for several real tests so you can validate your keyword strategy and email mode before scaling.

#### Do I need to log in or create an account on LinkedIn?

No, you don’t need a LinkedIn login to run this actor. It collects data from publicly available sources and outputs structured lead records in the dataset.

#### How accurate is the extracted data?

Accuracy depends on what contact information is publicly available in the source description text for each matched profile. The actor extracts emails from that text using pattern matching, and returns them in the `emails` array.

#### How many results can I get per run?

You control the cap using `maxLeadsPerKeyword` (1–500) for each keyword in `keywords`. The actor processes keywords separately, so total results scale with both the number of keywords and the cap per keyword.

#### How fresh is the data?

Freshness reflects what is available in the publicly accessible sources at the time the actor runs. If you re-run with the same inputs later, you may get different leads and different email lists.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor is designed to work with **publicly available data**. It’s your responsibility to comply with GDPR, CCPA, relevant platform terms, and all applicable local regulations for storing and using the collected leads.

#### Can I export to Google Sheets or Excel?

Yes. You can export your dataset as JSON, CSV, or Excel from the Apify dashboard, and then import into Google Sheets or another spreadsheet tool that accepts CSV/Excel.

#### Can I schedule this to run automatically?

Yes. You can run the actor on a schedule using Apify scheduling features so your lead generation stays consistent without manual launches.

#### Can I access results via the API?

Yes. Apify supports accessing actor runs and datasets via the Apify API, which makes it possible to automate ingestion into your systems and dashboards.

#### What happens when the actor encounters an error?

When scraping encounters issues, the actor uses retry logic and includes fallback behavior for empty pages. You’ll still get dataset output for the leads it can process, and errors are handled so the run can continue where possible.

***

### Get Help & Use Responsibly

Got a question about LinkedIn Leads Generator - B2B & B2C Email Finder or a feature you'd like added? Reach out at <dataforleads@gmail.com> — we’re happy to help and actively maintain this actor based on user feedback. If you share your ideal keyword patterns or desired output behavior (for example, outreach-only exports), we can guide you to the best settings.

**publicly available data** only: this actor does not access private accounts, login-gated pages, or password-protected content. You’re responsible for GDPR, CCPA, platform ToS, and any applicable regulations. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

List of keywords to search for LinkedIn profiles (e.g., 'software engineer', 'marketing manager', 'sales director'). Each keyword will be searched separately.

## `country` (type: `string`):

Filter results by country. Leave empty for worldwide results.

## `maxLeadsPerKeyword` (type: `integer`):

Maximum number of leads to collect for each keyword (1-500).

## `scrapeLeadsWithEmail` (type: `boolean`):

If enabled, will search for profiles that have emails in their Google search results (using common email providers like Gmail, Hotmail, Outlook, Yahoo). If disabled, will find all profiles matching keywords.

## Actor input object example

```json
{
  "keywords": [
    "software engineer",
    "marketing manager"
  ],
  "country": "United States",
  "maxLeadsPerKeyword": 20,
  "scrapeLeadsWithEmail": 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": [
        "software engineer",
        "marketing manager"
    ],
    "country": "United States",
    "maxLeadsPerKeyword": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapedrift/mass-linkedin-leads-generator").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": [
        "software engineer",
        "marketing manager",
    ],
    "country": "United States",
    "maxLeadsPerKeyword": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapedrift/mass-linkedin-leads-generator").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": [
    "software engineer",
    "marketing manager"
  ],
  "country": "United States",
  "maxLeadsPerKeyword": 20
}' |
apify call scrapedrift/mass-linkedin-leads-generator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mass Linkedin Leads Generator",
        "description": "🚀 Mass LinkedIn Leads Generator helps you bulk-extract high-quality lead data from LinkedIn. Find targeted prospects, boost outreach, and accelerate B2B sales & recruiting—fast, reliable, and scalable. 📈💼",
        "version": "1.0",
        "x-build-id": "asaTRGnhmug9fnfW9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapedrift~mass-linkedin-leads-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapedrift-mass-linkedin-leads-generator",
                "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/scrapedrift~mass-linkedin-leads-generator/runs": {
            "post": {
                "operationId": "runs-sync-scrapedrift-mass-linkedin-leads-generator",
                "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/scrapedrift~mass-linkedin-leads-generator/run-sync": {
            "post": {
                "operationId": "run-sync-scrapedrift-mass-linkedin-leads-generator",
                "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": "Search Keywords",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of keywords to search for LinkedIn profiles (e.g., 'software engineer', 'marketing manager', 'sales director'). Each keyword will be searched separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Target Country",
                        "enum": [
                            "United States",
                            "United Kingdom",
                            "Canada",
                            "Australia",
                            "India",
                            "Germany",
                            "France",
                            "Spain",
                            "Italy",
                            "Brazil",
                            "Mexico",
                            "Japan",
                            "South Korea",
                            "China",
                            "Singapore",
                            "United Arab Emirates",
                            "Netherlands",
                            "Sweden",
                            "Norway",
                            "Denmark",
                            "Switzerland",
                            "Belgium",
                            "Austria",
                            "Ireland",
                            "New Zealand",
                            "South Africa"
                        ],
                        "type": "string",
                        "description": "Filter results by country. Leave empty for worldwide results.",
                        "default": "United States"
                    },
                    "maxLeadsPerKeyword": {
                        "title": "Maximum Leads Per Keyword",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of leads to collect for each keyword (1-500).",
                        "default": 20
                    },
                    "scrapeLeadsWithEmail": {
                        "title": "Find Leads with Email Only",
                        "type": "boolean",
                        "description": "If enabled, will search for profiles that have emails in their Google search results (using common email providers like Gmail, Hotmail, Outlook, Yahoo). If disabled, will find all profiles matching keywords.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
