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

📧 LinkedIn Email Scraper finds and verifies business emails from LinkedIn profiles & search results—fast. 🔎 Enrich leads, boost outreach, and export to CSV/CRM. ⚡ Accurate matching, rate-limit aware, and ideal for sales, recruiting, and growth teams.

- **URL**: https://apify.com/scrapeflow/linkedin-email-scraper.md
- **Developed by:** [ScrapeFlow](https://apify.com/scrapeflow) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 3 total users, 0 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 Email Scraper

Linkedin Email Scraper is an Apify actor that searches Google for LinkedIn content matching your keywords, extracts valid email addresses from the results, and saves structured records to a dataset — perfect for sales teams, recruiters, marketers, developers, data analysts, and researchers looking to build targeted contact lists at scale. It removes the manual work of digging through search results and lets you control location, domains, limits, and resilient proxying so you can enrich leads and accelerate outreach faster.

### What data / output can you get?

The actor stores clean, structured rows in the dataset for each email it finds in Google results that link to LinkedIn. Fields are pushed exactly as below:

| Data type   | Description                                                         | Example value |
| --- | --- | --- |
| network     | Network label derived from the selected platform                    | "Linkedin.com" |
| keyword     | The search keyword that produced the match                          | "marketing" |
| title       | Result title extracted from the SERP block                          | "Social Lift Marketing (@socialliftmarketing)" |
| description | Result snippet/preview text from the SERP block                     | "This is Tunbridge Wells Squash ... socialliftmarketing@outlook.com ..." |
| url         | The LinkedIn result URL                                             | "https://www.linkedin.com/socialliftmarketing/" |
| email       | Email address extracted from the SERP block using regex             | "socialliftmarketing@outlook.com" |

All results are saved to the Apify dataset so you can download or integrate them into your workflows.

### Key features

- ⚙️ Bold Google SERP targeting
  Searches Google with a strict site filter for LinkedIn and parses result blocks with resilient CSS selector fallbacks to maximize extraction from diverse SERP layouts.

- 🎯 Email domain filtering
  Use the emailDomains filter to keep only addresses ending with specific domains (e.g., "@company.com", "@gmail.com") for precise B2B or personal targeting.

- 📍 Location-aware queries
  Add an optional location (e.g., "London", "Berlin") to refine searches and surface region-relevant results.

- 📈 Per-keyword collection limits
  Control run time and dataset size with maxEmails (1–5000) per keyword. The actor stops after the cap is reached for each term.

- 🔄 Proxy rotation & fallbacks
  The legacy engine initializes with the GOOGLE_SERP proxy and can fall back to datacenter and residential proxies with up to 3 retries when requests are blocked.

- 🧠 Block-awareness and jitter
  Randomized headers, user-agents, accept-language, and jittered delays reduce rate-limit risk; block strings are detected to trigger proxy fallbacks.

- 🗂️ Structured dataset output
  Every matched record is pushed with network, keyword, title, description, url, and email — consistent, ready for downstream use.

- 🔐 No login or cookies required
  The actor extracts emails from public Google SERP snippets that link to LinkedIn — no account access or authenticated pages.

- 🐍 Python-based reliability
  Built with the Apify Python SDK, aiohttp, and BeautifulSoup for performance, stability, and maintainability on the Apify platform.

### How to use Linkedin Email Scraper - step by step

1. Sign in to Apify.
2. Open the “Linkedin Email Scraper” actor from the Apify Store.
3. Add your keywords in the keywords array (e.g., ["marketing", "founder"]).
4. Optionally set location to narrow results by city or region (e.g., "London").
5. Optionally add emailDomains to keep only desired domains (e.g., ["@company.com", "@gmail.com"]).
6. Set maxEmails to cap how many emails to collect per keyword (1–5000; default 20).
7. Confirm platform is "Linkedin" and engine is "legacy" (default).
8. Optionally provide proxyConfiguration if you need a custom setup; otherwise the legacy engine initializes with GOOGLE_SERP and handles fallbacks automatically.
9. Start the run and monitor logs as pages are processed and emails are collected.
10. When complete, open the dataset to view rows with network, keyword, title, description, url, and email, then download for your workflow.

Pro tip: Use emailDomains with company-specific domains (e.g., "@acme.com") to build highly targeted B2B lists from your keyword set.

### Use cases

| Use case name | Description |
| --- | --- |
| Sales prospecting + outreach | Build targeted lead lists by collecting emails surfaced in Google results for LinkedIn content matching role, industry, or niche keywords. |
| Recruiting + talent sourcing | Identify candidate contact emails from role- and skill-based searches combined with optional location filters. |
| B2B enrichment for CRM | Enrich existing records by querying company or role keywords and filtering emails by corporate domains. |
| Growth marketing list building | Generate contact lists aligned to campaign themes using keyword-driven discovery and per-keyword limits. |
| Agency lead generation | Quickly assemble contact emails for verticals (e.g., “SaaS marketing”) using domain and location filters. |
| Academic and market research | Collect public emails associated with LinkedIn-linked content to support surveys and expert panels. |
| Developer automation pipeline | Feed structured dataset outputs (network, keyword, title, description, url, email) into ETL jobs and analytics. |

### Why choose Linkedin Email Scraper?

A precise, resilient, and production-ready email extraction actor built for repeatable results at scale.

- 🎯 Accuracy-first parsing: Extracts emails from SERP blocks with robust regex and selector fallbacks tailored for Google results.
- 🔄 Resilient networking: Starts with GOOGLE_SERP proxy on the legacy engine and falls back to datacenter and residential proxies with retries when needed.
- 🧩 Flexible filtering: Target the right contacts with keyword, optional location, and emailDomains filters.
- 🚫 No login required: Works from public Google SERPs that link to LinkedIn — no cookies, extensions, or account access.
- 🐍 Developer-grade stack: Python, aiohttp, BeautifulSoup, and the Apify SDK for stability on managed infrastructure.
- 🗂️ Clean, consistent output: Structured dataset rows with clear fields for straightforward downstream processing.

Unlike browser extensions and unstable scripts, this actor is designed for reliability, proxy-aware execution, and structured outputs you can trust.

### Is it legal / ethical to use Linkedin Email Scraper?

Yes — when used responsibly. This actor extracts emails that appear in public Google search result snippets linking to LinkedIn content and does not access private or authenticated pages.

Guidelines:
- Collect and use only publicly visible information.
- Respect LinkedIn’s terms of service and applicable laws (e.g., GDPR, CCPA).
- Use data for legitimate purposes and avoid spam or deceptive outreach.
- Consult your legal team to ensure compliance in your jurisdiction and use case.

### Input parameters & output format

#### Example input (JSON)
```json
{
  "keywords": [
    "marketing",
    "founder",
    "business"
  ],
  "platform": "Linkedin",
  "location": "London",
  "emailDomains": [
    "@gmail.com",
    "@outlook.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Parameter reference:

- keywords (array, required): List of search terms to find LinkedIn profiles or posts. Each keyword is processed separately. Default: none.
- platform (string, optional): Social/professional platform to target; currently supports "Linkedin". Default: "Linkedin".
- location (string, optional): Optional location to refine queries (e.g., "London"). Default: "".
- emailDomains (array, optional): Optional list of domains to keep (e.g., "@company.com"). Default: none.
- maxEmails (integer, optional): Maximum emails to collect per keyword (1–5000). Default: 20.
- engine (string, optional): Scraping engine. Supported: "legacy". Default: "legacy".
- proxyConfiguration (object, optional): Proxy settings. With the legacy engine, the actor initializes with a GOOGLE\_SERP proxy and can fall back to datacenter and residential proxies with retries. Default: not set by input.

#### Example output (JSON)

```json
{
  "network": "Linkedin.com",
  "keyword": "marketing",
  "title": "Social Lift Marketing (@socialliftmarketing)",
  "description": "This is Tunbridge Wells Squash ... 07802 640882 socialliftmarketing@outlook.com #SocialMediaMarketing ...",
  "url": "https://www.linkedin.com/socialliftmarketing/",
  "email": "socialliftmarketing@outlook.com"
}
```

Notes:

- The actor pushes only rows that contain an email.
- description may be an empty string if the SERP snippet lacks text.

### FAQ

#### Is there a free trial for this actor?

Yes. The listing includes 120 trial minutes so you can evaluate performance before subscribing.

#### Do I need a LinkedIn login or cookies to run this?

No. The actor works from public Google SERP results that link to LinkedIn content and does not require login or cookies.

#### Can I filter emails by specific domains?

Yes. Use the emailDomains array to keep only emails ending with domains you specify (e.g., "@company.com", "@gmail.com").

#### Can I narrow results by location?

Yes. Provide a location string (e.g., "London", "New York") to refine searches geographically.

#### How many emails can it collect per keyword?

You control this with maxEmails. Set any value from 1 to 5000; the default is 20 per keyword.

#### What output fields are included in the dataset?

Each record contains network, keyword, title, description, url, and email. Only rows with an email are pushed.

#### Does the actor verify emails?

No. It extracts email addresses found in public SERP snippets using a regex. Verification/validation is not performed.

#### Which proxies does it use and how are blocks handled?

With the legacy engine, the actor initializes with a GOOGLE\_SERP proxy and will fall back to datacenter and residential proxies, retrying up to 3 times when it detects blocks.

### Final thoughts

Linkedin Email Scraper is built to extract public email addresses tied to LinkedIn-related search results quickly and reliably. With keyword-driven discovery, optional location and domain filters, structured outputs, and resilient proxying, it helps sales, recruiting, marketing, research, and engineering teams move from manual discovery to scalable contact collection. Developers benefit from a Python-based, Apify-managed workflow and clean dataset outputs ready for pipelines. Start extracting smarter, structured email data for your outreach today.

# Actor input Schema

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

📌 List of search terms to find LinkedIn profiles or posts (e.g. 'marketing', 'founder', 'business'). The actor searches Google for LinkedIn content containing these keywords and extracts email addresses from the results. Add as many keywords as you need — each will be processed separately.

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

📱 Choose the social/professional platform to scrape. Currently supports LinkedIn — more platforms may be added in future updates.

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

🌍 Optional: Narrow results by location (e.g. 'London', 'New York', 'Berlin'). Added to the search query to find profiles or posts from that area. Leave empty to search globally without a location filter.

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

✉️ Optional: Only keep emails from these domains (e.g. '@gmail.com', '@outlook.com', '@company.com'). Useful for B2B (corporate domains) or personal (Gmail/Outlook). Leave empty to collect emails from all domains.

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

🎯 Cap how many emails to collect for each keyword (1–5000). Stops after reaching this number per keyword, so you can control run time and dataset size. Default: 20.

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

🔧 **Legacy:** Uses GOOGLE\_SERP proxy with traditional selectors — more reliable for strict Google results, but slower and typically more expensive. Best when you need consistent, stable results.

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

🌐 Choose which proxies to use for requests. By default, no proxy is used. If Google blocks or rejects requests, the actor automatically tries datacenter proxy, then residential proxy, with up to 3 retries — so your run is more resilient.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Linkedin",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeflow/linkedin-email-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeflow/linkedin-email-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapeflow/linkedin-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linkedin Email Scraper",
        "description": "📧 LinkedIn Email Scraper finds and verifies business emails from LinkedIn profiles & search results—fast. 🔎 Enrich leads, boost outreach, and export to CSV/CRM. ⚡ Accurate matching, rate-limit aware, and ideal for sales, recruiting, and growth teams.",
        "version": "0.1",
        "x-build-id": "04USO4dfuJFFMdZdF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeflow~linkedin-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeflow-linkedin-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapeflow~linkedin-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeflow-linkedin-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapeflow~linkedin-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeflow-linkedin-email-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "🔑 Keywords",
                        "type": "array",
                        "description": "📌 List of search terms to find LinkedIn profiles or posts (e.g. 'marketing', 'founder', 'business'). The actor searches Google for LinkedIn content containing these keywords and extracts email addresses from the results. Add as many keywords as you need — each will be processed separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "🌐 Platform",
                        "enum": [
                            "Linkedin"
                        ],
                        "type": "string",
                        "description": "📱 Choose the social/professional platform to scrape. Currently supports LinkedIn — more platforms may be added in future updates.",
                        "default": "Linkedin"
                    },
                    "location": {
                        "title": "📍 Location Filter",
                        "type": "string",
                        "description": "🌍 Optional: Narrow results by location (e.g. 'London', 'New York', 'Berlin'). Added to the search query to find profiles or posts from that area. Leave empty to search globally without a location filter.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "📬 Email Domains Filter",
                        "type": "array",
                        "description": "✉️ Optional: Only keep emails from these domains (e.g. '@gmail.com', '@outlook.com', '@company.com'). Useful for B2B (corporate domains) or personal (Gmail/Outlook). Leave empty to collect emails from all domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "📊 Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "🎯 Cap how many emails to collect for each keyword (1–5000). Stops after reaching this number per keyword, so you can control run time and dataset size. Default: 20.",
                        "default": 20
                    },
                    "engine": {
                        "title": "⚙️ Scraping Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "🔧 **Legacy:** Uses GOOGLE_SERP proxy with traditional selectors — more reliable for strict Google results, but slower and typically more expensive. Best when you need consistent, stable results.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy Configuration",
                        "type": "object",
                        "description": "🌐 Choose which proxies to use for requests. By default, no proxy is used. If Google blocks or rejects requests, the actor automatically tries datacenter proxy, then residential proxy, with up to 3 retries — so your run is more resilient."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```