# LinkedIn Profile Scraper + Verified Email Leads (`flash_scraper/linkedin-leads-scraper`) Actor

Scrape LinkedIn profiles by URL or search query into a contactable lead list — name, title/headline, company, location, profile URL, plus a verified email (seeded or enriched from a personal/company site), phone, a 0-100 lead score, dedupe, and optional AI cold openers. Export CSV/JSON.

- **URL**: https://apify.com/flash\_scraper/linkedin-leads-scraper.md
- **Developed by:** [Flash Scrape](https://apify.com/flash_scraper) (community)
- **Categories:** Lead generation, Social media, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.00 / 1,000 leads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Scraper — turn profiles and searches into contactable, scored leads

**Turn LinkedIn profiles into a lead list you can actually email.** Feed this actor LinkedIn `/in/` profile URLs and/or free-text people searches (e.g. *"VP of Marketing SaaS"*) and get back one clean row per person: **name, title/headline, company, location, profile URL, email, phone, website**, an `email_status` flag, and a **0–100 lead score** that sorts the best leads first. Built for B2B cold email, recruiting, sales prospecting, and agency outreach teams that are tired of raw profile dumps that still need hours of spreadsheet cleanup. It's **pay-per-result** — you're charged only for the leads delivered after your filters — and it needs **no LinkedIn login or cookie**.

### What it does

- **Scrapes LinkedIn profiles** from `/in/` URLs, public identifiers, or free-text search queries — profile data is fetched through the [`harvestapi/linkedin-profile-scraper`](https://apify.com/harvestapi/linkedin-profile-scraper) data provider, so no LinkedIn cookie or credentials are ever needed.
- **Finds an email for each person**: the email search on the profile side is seeded first, then (with `enrichEmails` on) the actor visits any **personal or company website** linked from the profile — home, `/contact`, `/contact-us`, and `/about` pages — and extracts real emails plus LinkedIn/Facebook/Twitter social links. Link-in-bio pages (Linktree, Beacons, etc.) are resolved one hop further, but only to domains that match the person's own name or handle, so a sponsor's email never sneaks into your list.
- **Filters before you pay**: keep only people whose title/headline contains your keywords (`titleIncludes`), only people with a website, or only people with an email.
- **Scores every lead 0–100** — email +40, phone +10, title/seniority match +15, company present +10, location +5 — and sorts the dataset best-first.
- **Dedupes automatically** by profile URL and email, so the same person never appears twice.
- **Optionally writes an AI cold-email opener** per lead (one personalized sentence referencing their role or company), using **your own** OpenAI or Anthropic API key — the key is used once per run and never stored.

### Use cases

- **B2B cold email** — turn a search like *"founder fintech London"* into a deduped, scored list with emails, ready for your sequencer.
- **Recruiting** — convert a shortlist of candidate profile URLs into an enriched CSV with contact details for direct outreach.
- **Sales prospecting** — build a decision-maker list filtered by title keywords (CEO, Head of, Director) and sorted by contactability.
- **Agency lead gen** — deliver clean LinkedIn lead lists to clients as a productized service, exported to CSV or synced to a CRM.
- **Account-based marketing** — enrich a target-account contact list with emails, phones, and websites in one run.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `profileUrls` | array | — | LinkedIn `/in/` profile URLs or public identifiers, one per line (e.g. `https://www.linkedin.com/in/williamhgates/` or `williamhgates`). |
| `searchQueries` | array | — | Free-text people searches, one per line (e.g. `VP of Marketing SaaS`). Use instead of, or alongside, profile URLs. |
| `maxItems` | integer | `50` | Maximum profiles to scrape across all URLs and queries (1–1000). |
| `titleIncludes` | array | — | Keep only people whose title/headline contains one of these keywords. Matches also add to the lead score. |
| `onlyWithWebsite` | boolean | `false` | Drop people with no personal/company website. |
| `onlyWithEmail` | boolean | `false` | Drop people where no email could be found — best for cold-email campaigns. |
| `enrichEmails` | boolean | `true` | Turn on the email search and visit the linked website to extract emails and social links. |
| `writeOpeners` | boolean | `false` | Generate a personalized one-sentence AI opener per lead (requires your key below). |
| `llmProvider` | string | `"openai"` | `openai` or `anthropic` — which model writes the openers. |
| `llmApiKey` | string | — | Your own OpenAI/Anthropic API key. Used only for openers; never stored. |
| `llmModel` | string | — | Optional model override (defaults: `gpt-4o-mini` / `claude-haiku-4-5`). |

```json
{
  "profileUrls": ["https://www.linkedin.com/in/williamhgates/"],
  "searchQueries": ["VP of Marketing SaaS"],
  "maxItems": 50,
  "titleIncludes": ["CEO", "Founder", "Head of"],
  "onlyWithEmail": true,
  "enrichEmails": true,
  "writeOpeners": false
}
````

Provide at least one of `profileUrls` or `searchQueries` — everything else has a sensible default.

### Output

One dataset row per unique person, sorted best lead first. Rows export to CSV, JSON, or Excel from the Output tab, or via the Apify API.

```json
{
  "name": "Jane Doe",
  "title": "VP of Marketing at Acme SaaS",
  "headline": "VP of Marketing at Acme SaaS",
  "company": "Acme SaaS",
  "location": "Austin, Texas, United States",
  "profile_url": "https://www.linkedin.com/in/janedoe/",
  "handle": "janedoe",
  "email": "jane@acmesaas.com",
  "phone": null,
  "website": "https://acmesaas.com",
  "email_status": "found",
  "lead_score": 70
}
```

When website enrichment finds more, rows also carry `extra_emails` (up to 5 additional addresses) and any `linkedin` / `facebook` / `twitter` company links found on the site. With `writeOpeners` on, each lead gets an `icebreaker` field.

### Pricing

This actor uses Apify **pay-per-event pricing: a fraction of a cent per result — see the Pricing tab** for the exact rate. You're charged only for leads **delivered after dedup and your filters** — if you set `onlyWithEmail`, you don't pay for the profiles that had no email. There's no subscription and no charge for empty runs, and the **free Apify plan is enough to try it** on a real prospect list before spending anything.

### Tips / FAQ

**Will every profile have an email?** No. Emails come from the profile-side email search and from the person's own linked website. People with no public email anywhere show `email_status: "missing"` — turn on `onlyWithEmail` to keep only contactable leads (and to pay only for them).

**Are the emails deliverability-verified?** They're extracted from real public sources, but this actor doesn't do SMTP verification. Run the output through the [Bulk Email Verifier](https://apify.com/flash_scraper/email-verifier) before a large campaign.

**Do I need a LinkedIn account, cookie, or API key?** No login and no cookie. The only optional key is your own OpenAI/Anthropic key, and only if you want AI openers.

**Where does the profile data come from?** Profiles are fetched via an upstream data provider (`harvestapi/linkedin-profile-scraper`). If that provider has a transient outage, this run ends gracefully with a "temporarily unavailable — please retry" message and **you're charged nothing**.

**How does `maxItems` behave?** The upstream provider returns roughly one profile per URL or query; the cap is enforced on this actor's side, so you never receive (or pay for) more than `maxItems` leads.

**Is this legal?** It reads **public** profile data only. Use the leads for legitimate outreach and follow LinkedIn's terms plus anti-spam laws (CAN-SPAM, GDPR) in your messaging.

### Related actors

- [Bulk Email Verifier](https://apify.com/flash_scraper/email-verifier) — verify every email before you hit send
- [Company & Domain Enricher](https://apify.com/flash_scraper/company-domain-enricher) — turn lead websites into full company records
- [Twitter/X Leads Scraper](https://apify.com/flash_scraper/twitter-leads-scraper) — the same scored-leads approach for X/Twitter audiences

**Support:** found a bug or need a feature? Open an Issue on this actor's **Issues tab** — typical response within 1 business day.

# Actor input Schema

## `profileUrls` (type: `array`):

LinkedIn /in/ profile URLs (or public identifiers) to turn into leads — one per line. e.g. 'https://www.linkedin.com/in/williamhgates/' or 'williamhgates'.

## `searchQueries` (type: `array`):

Free-text searches to find people — one per line. e.g. 'VP of Marketing SaaS', 'founder fintech London'. Use instead of, or alongside, profile URLs.

## `maxItems` (type: `integer`):

Maximum number of LinkedIn profiles to scrape across all URLs and queries.

## `titleIncludes` (type: `array`):

Keep only people whose title or headline contains one of these keywords (e.g. 'CEO', 'Head of Sales', 'Director'). Empty = no filter. Matches also add to the lead score.

## `onlyWithWebsite` (type: `boolean`):

Drop people with no personal/company website (you can't enrich an email without one).

## `onlyWithEmail` (type: `boolean`):

Drop people where no email could be found. Best for cold-email campaigns.

## `enrichEmails` (type: `boolean`):

Turn on the scraper's email search, and also visit any linked website (home + /contact + /about) to extract emails and social links. Higher email fill-rate.

## `writeOpeners` (type: `boolean`):

Generate a personalized one-sentence outreach opener for each lead. Requires your OpenAI/Anthropic key below.

## `llmProvider` (type: `string`):

AI provider used to write the cold openers — OpenAI (GPT) or Anthropic (Claude). Use the provider that matches the LLM API key you supply.

## `llmApiKey` (type: `string`):

Your own OpenAI or Anthropic API key. Used only to write the openers; never stored.

## `llmModel` (type: `string`):

Override the default model (gpt-4o-mini for OpenAI, claude-haiku-4-5-20251001 for Anthropic).

## Actor input object example

```json
{
  "profileUrls": [
    "satyanadella",
    "https://www.linkedin.com/in/jeffweiner08/"
  ],
  "searchQueries": [
    "VP of Marketing SaaS",
    "founder fintech London"
  ],
  "maxItems": 50,
  "titleIncludes": [
    "CEO",
    "Founder",
    "Head of"
  ],
  "onlyWithWebsite": false,
  "onlyWithEmail": false,
  "enrichEmails": true,
  "writeOpeners": false,
  "llmProvider": "openai"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "profileUrls": [
        "https://www.linkedin.com/in/williamhgates/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("flash_scraper/linkedin-leads-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 = { "profileUrls": ["https://www.linkedin.com/in/williamhgates/"] }

# Run the Actor and wait for it to finish
run = client.actor("flash_scraper/linkedin-leads-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 '{
  "profileUrls": [
    "https://www.linkedin.com/in/williamhgates/"
  ]
}' |
apify call flash_scraper/linkedin-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Profile Scraper + Verified Email Leads",
        "description": "Scrape LinkedIn profiles by URL or search query into a contactable lead list — name, title/headline, company, location, profile URL, plus a verified email (seeded or enriched from a personal/company site), phone, a 0-100 lead score, dedupe, and optional AI cold openers. Export CSV/JSON.",
        "version": "0.1",
        "x-build-id": "pO40zWJcl1qqcIcAt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/flash_scraper~linkedin-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-flash_scraper-linkedin-leads-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/flash_scraper~linkedin-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-flash_scraper-linkedin-leads-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/flash_scraper~linkedin-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-flash_scraper-linkedin-leads-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",
                "properties": {
                    "profileUrls": {
                        "title": "LinkedIn profile URLs",
                        "type": "array",
                        "description": "LinkedIn /in/ profile URLs (or public identifiers) to turn into leads — one per line. e.g. 'https://www.linkedin.com/in/williamhgates/' or 'williamhgates'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Free-text searches to find people — one per line. e.g. 'VP of Marketing SaaS', 'founder fintech London'. Use instead of, or alongside, profile URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max profiles",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of LinkedIn profiles to scrape across all URLs and queries.",
                        "default": 50
                    },
                    "titleIncludes": {
                        "title": "Title / headline contains",
                        "type": "array",
                        "description": "Keep only people whose title or headline contains one of these keywords (e.g. 'CEO', 'Head of Sales', 'Director'). Empty = no filter. Matches also add to the lead score.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "onlyWithWebsite": {
                        "title": "Only profiles with a website",
                        "type": "boolean",
                        "description": "Drop people with no personal/company website (you can't enrich an email without one).",
                        "default": false
                    },
                    "onlyWithEmail": {
                        "title": "Only profiles with an email",
                        "type": "boolean",
                        "description": "Drop people where no email could be found. Best for cold-email campaigns.",
                        "default": false
                    },
                    "enrichEmails": {
                        "title": "Find verified emails",
                        "type": "boolean",
                        "description": "Turn on the scraper's email search, and also visit any linked website (home + /contact + /about) to extract emails and social links. Higher email fill-rate.",
                        "default": true
                    },
                    "writeOpeners": {
                        "title": "Write an AI cold-opener per lead",
                        "type": "boolean",
                        "description": "Generate a personalized one-sentence outreach opener for each lead. Requires your OpenAI/Anthropic key below.",
                        "default": false
                    },
                    "llmProvider": {
                        "title": "AI provider (for openers)",
                        "enum": [
                            "openai",
                            "anthropic"
                        ],
                        "type": "string",
                        "description": "AI provider used to write the cold openers — OpenAI (GPT) or Anthropic (Claude). Use the provider that matches the LLM API key you supply.",
                        "default": "openai"
                    },
                    "llmApiKey": {
                        "title": "AI API key (for openers)",
                        "type": "string",
                        "description": "Your own OpenAI or Anthropic API key. Used only to write the openers; never stored."
                    },
                    "llmModel": {
                        "title": "AI model (optional)",
                        "type": "string",
                        "description": "Override the default model (gpt-4o-mini for OpenAI, claude-haiku-4-5-20251001 for Anthropic)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
