# B2B Lead Finder — Emails, Phones & Contacts (`khadinakbar/universal-lead-finder`) Actor

Find B2B leads from any niche and location. Enter a business type and city — the actor searches DuckDuckGo, visits business websites, and extracts emails, phones, addresses, LinkedIn, social links, and lead scores. Works for lawyers, dentists, plumbers, agencies, and more. No API key needed.

- **URL**: https://apify.com/khadinakbar/universal-lead-finder.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, Automation, MCP servers
- **Stats:** 9 total users, 6 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

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

## 🔍 Universal B2B Lead Finder — Emails, Phones & Business Contacts

**Find verified B2B leads with emails, phone numbers, addresses, social media links, and lead scores — no cookies, no API keys, no login required.**

Export to JSON, CSV, or Excel. Run via API, schedule automated runs, or integrate with any CRM or outreach tool.

---

### What does Universal B2B Lead Finder do?

Universal B2B Lead Finder discovers business leads from **Yellow Pages** by keyword and location, then enriches each lead by crawling their website to extract email addresses, social media profiles, and additional phone numbers — all in a single run. It also accepts direct website URLs for contact extraction. The result is a CRM-ready dataset with every reachable contact channel for each business.

---

### Why use Universal B2B Lead Finder?

- **No cookies or login required** — works out of the box, no browser extension setup, no Apollo/LinkedIn account needed
- **All-in-one** — search + website email enrichment + social extraction in one actor, not three chained actors
- **Lead scoring** — every lead gets a 0–100 score based on data completeness so you can prioritize outreach instantly
- **3× cheaper than alternatives** — at **$0.003 per lead** versus $0.006–$0.012 for similar actors
- **Consistent 95%+ success rate** — robust fallback selectors and graceful error handling

---

### What data does Universal B2B Lead Finder extract?

| Field | Type | Description | Example |
|-------|------|-------------|---------|
| `business_name` | string | Official business name | `Miami Smile Dental` |
| `category` | string | Industry / business type | `Dentists` |
| `address` | string | Street address | `1234 Brickell Ave Suite 500` |
| `city` | string | City | `Miami` |
| `state` | string | US state abbreviation | `FL` |
| `zip` | string | ZIP code | `33131` |
| `phone` | string | Primary phone number | `(305) 555-0198` |
| `website` | string | Business website URL | `https://miamismile.com` |
| `email` | string | Primary email address | `contact@miamismile.com` |
| `all_emails` | array | All emails found | `["contact@...", "info@..."]` |
| `linkedin_url` | string | LinkedIn company/profile URL | `https://linkedin.com/company/...` |
| `facebook_url` | string | Facebook page URL | `https://facebook.com/...` |
| `twitter_url` | string | Twitter / X profile URL | `https://twitter.com/...` |
| `instagram_url` | string | Instagram profile URL | `https://instagram.com/...` |
| `youtube_url` | string | YouTube channel URL | `https://youtube.com/c/...` |
| `rating` | number | Star rating from directory (1–5) | `4.7` |
| `review_count` | integer | Number of reviews | `128` |
| `lead_score` | integer | Data completeness score (0–100) | `85` |
| `source_url` | string | Where the lead was found | `https://yellowpages.com/...` |
| `scraped_at` | string | ISO 8601 extraction timestamp | `2026-04-13T10:30:00Z` |

**Lead score breakdown:** email +30, phone +20, website +15, LinkedIn +15, address +10, Facebook +5, Instagram +5.

---

### How to use Universal B2B Lead Finder

#### Option A: Search by keyword (most common)

1. Open the actor and enter a **Search Query** like `"dentists in Miami"` or `"plumbers Chicago"`
2. Optionally set a **Location** for precision (e.g., `"Miami, FL"`)
3. Set **Max Results** (default 50, max 1,000)
4. Leave **Enrich with website data** enabled for email + social enrichment
5. Click **Start**

The actor searches Yellow Pages, collects all business listings, visits each website, extracts emails and social links, and returns a ranked dataset sorted by lead score.

#### Option B: Extract contacts from known websites

1. Paste your list of company website URLs into **Website URLs (direct mode)**
2. The actor crawls each site's homepage, /contact, and /about pages
3. Returns emails, phones, and social links for each domain

#### Option C: Both modes together

Supply both `searchQuery` and `startUrls` — all sources will be processed in a single run.

---

### Tutorial: Find 50 Dental Office Leads in Miami

```javascript
// Run via Apify API
const { ApifyClient } = require('apify-client');
const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('khadinakbar/universal-lead-finder').call({
    searchQuery: 'dental offices',
    location: 'Miami, FL',
    maxResults: 50,
    crawlWebsites: true,
    includeSubpages: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
// Filter leads with emails and sort by lead score
const qualified = items
    .filter(lead => lead.email)
    .sort((a, b) => b.lead_score - a.lead_score);

console.log(`Found ${qualified.length} leads with emails`);
console.log(qualified[0]);
// { business_name: 'Miami Smile Dental', email: 'hello@miamismile.com', phone: '(305)...', lead_score: 85, ... }
````

#### Python example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("khadinakbar/universal-lead-finder").call(run_input={
    "searchQuery": "dental offices",
    "location": "Miami, FL",
    "maxResults": 50,
    "crawlWebsites": True,
})

dataset = client.dataset(run["defaultDatasetId"])
leads = [item for item in dataset.iterate_items()]
## Sort by lead_score descending
leads.sort(key=lambda x: x.get("lead_score", 0), reverse=True)
print(f"Top lead: {leads[0]['business_name']} — {leads[0]['email']}")
```

***

### Pricing

This actor uses **pay-per-event pricing**: **$0.003 per lead extracted**.

| Leads | Cost |
|-------|------|
| 10 leads | $0.03 |
| 50 leads | $0.15 |
| 100 leads | $0.30 |
| 500 leads | $1.50 |
| 1,000 leads | $3.00 |

**Compare:** Similar actors charge $0.006–$0.012 per result. Universal B2B Lead Finder delivers the same or better data at 50–75% lower cost.

***

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | — | Keyword search (e.g., "dentists in Miami") |
| `location` | string | — | City/state for search precision |
| `startUrls` | array | `[]` | Direct company website URLs |
| `maxResults` | integer | `50` | Max leads to extract (1–1,000) |
| `crawlWebsites` | boolean | `true` | Enrich leads with email & social from websites |
| `includeSubpages` | boolean | `true` | Also crawl /contact and /about for more emails |
| `proxyConfiguration` | object | SHADER | Proxy group settings |

***

### Use Cases

**Sales Prospecting** — Build targeted outreach lists for any industry and city. Import directly into HubSpot, Salesforce, or Pipedrive.

**Agency Lead Generation** — Find local businesses that might need your services (SEO, web design, marketing). Filter by lead score to prioritize those with weak online presence.

**Recruitment** — Identify companies in a specific niche and location, find their contact emails for outreach.

**Market Research** — Map all businesses in a category across multiple cities, gather contact and rating data for competitive analysis.

**Cold Email Campaigns** — Feed leads directly into tools like Instantly, Smartlead, or Apollo for automated outreach sequences.

***

### Frequently Asked Questions

**Does this require any login or cookies?**
No. Universal B2B Lead Finder works entirely from public sources. No Apollo account, no LinkedIn cookies, no browser extensions needed.

**What happens if a website doesn't have an email?**
The lead is still returned with whatever data was found (name, phone, address, social links). The `email` field will be `null` and the lead score will reflect the missing data.

**How accurate are the emails?**
Emails are extracted from actual `mailto:` links and text on business websites — these are the same emails the business publicly lists for contact. Junk/system emails are automatically filtered out.

**Can I search outside the US?**
Yellow Pages is US-focused. For international leads, use the `startUrls` mode with domain lists from local directories.

**Why is the lead score useful?**
A score of 70+ means the lead has email + phone + LinkedIn — you can reach them via 3 channels. A score of 20 means you only have a phone number. Use score filters in your CRM to prioritize outreach effort.

**How do I export to CSV or Excel?**
After the run finishes, click **Export** in the Apify Console dataset view. Choose CSV, Excel (XLSX), or JSON.

**What's the difference between `crawlWebsites: true` and `false`?**
With `true` (default), the actor visits each business website to find their email address and social profiles. With `false`, you get faster results but only phone/address/category data from the directory.

***

### Works Great With

- **[Apify's Google Maps Scraper](https://apify.com/compass/crawler-google-places)** — get leads from Google Maps, then enrich them with this actor's email extraction
- **HubSpot / Salesforce / Pipedrive** — export the dataset as CSV and import directly
- **Instantly / Smartlead / Apollo** — export leads for cold email campaigns
- **Zapier / Make** — trigger runs via webhook and push results to your CRM automatically

***

### Legal Disclaimer

*This actor collects data from publicly accessible web pages. Users are responsible for ensuring their use complies with applicable laws, website terms of service, and data protection regulations (GDPR, CCPA, CAN-SPAM). This tool is intended for lawful B2B prospecting from public sources only.*

***

### Support

Questions or feature requests? Open an issue in the actor's **Issues** tab. Response within 48 hours guaranteed.

# Actor input Schema

## `searchQuery` (type: `string`):

Use this field when the user provides a keyword or business type to search for (e.g., 'dentists in Miami', 'plumbers Chicago', 'SaaS companies New York'). Use startUrls instead when direct website URLs are provided.

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

City, state, or ZIP code to target (e.g., 'Miami, FL', 'New York, NY', '90210'). Improves search precision. You can also include location directly in the searchQuery above.

## `startUrls` (type: `array`):

Use this field when the user provides specific company website URLs to extract contact info from. The actor will crawl each site for emails, phones, and social links. Do NOT use this when the user describes a keyword or niche — use searchQuery for that.

## `maxResults` (type: `integer`):

Maximum number of business leads to extract. Each lead counts as one billable event. Default: 50. Max: 1000.

## `crawlWebsites` (type: `boolean`):

When enabled, visits each business website to extract email addresses and social media links. Recommended — this is what makes leads actionable. Disable only if you need only phone/address data faster.

## `includeSubpages` (type: `boolean`):

Also crawl /contact, /about, /team subpages for better email coverage. Slower but finds more emails.

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

Proxy settings for scraping. Datacenter proxies (default) work for most sites. Use Residential if you experience blocks.

## Actor input object example

```json
{
  "searchQuery": "dentists in Miami",
  "location": "Miami, FL",
  "startUrls": [],
  "maxResults": 50,
  "crawlWebsites": true,
  "includeSubpages": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All extracted business leads with contact details (email, phone, social), address, ratings, and lead scores. CRM-ready JSON.

# 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 = {
    "searchQuery": "dentists in Miami",
    "location": "Miami, FL",
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/universal-lead-finder").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 = {
    "searchQuery": "dentists in Miami",
    "location": "Miami, FL",
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/universal-lead-finder").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 '{
  "searchQuery": "dentists in Miami",
  "location": "Miami, FL",
  "maxResults": 50
}' |
apify call khadinakbar/universal-lead-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "B2B Lead Finder — Emails, Phones & Contacts",
        "description": "Find B2B leads from any niche and location. Enter a business type and city — the actor searches DuckDuckGo, visits business websites, and extracts emails, phones, addresses, LinkedIn, social links, and lead scores. Works for lawyers, dentists, plumbers, agencies, and more. No API key needed.",
        "version": "1.0",
        "x-build-id": "biyRu4kosPu8lQlt4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~universal-lead-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-universal-lead-finder",
                "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/khadinakbar~universal-lead-finder/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-universal-lead-finder",
                "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/khadinakbar~universal-lead-finder/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-universal-lead-finder",
                "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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Use this field when the user provides a keyword or business type to search for (e.g., 'dentists in Miami', 'plumbers Chicago', 'SaaS companies New York'). Use startUrls instead when direct website URLs are provided."
                    },
                    "location": {
                        "title": "Location (optional)",
                        "type": "string",
                        "description": "City, state, or ZIP code to target (e.g., 'Miami, FL', 'New York, NY', '90210'). Improves search precision. You can also include location directly in the searchQuery above."
                    },
                    "startUrls": {
                        "title": "Website URLs (direct mode)",
                        "type": "array",
                        "description": "Use this field when the user provides specific company website URLs to extract contact info from. The actor will crawl each site for emails, phones, and social links. Do NOT use this when the user describes a keyword or niche — use searchQuery for that.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of business leads to extract. Each lead counts as one billable event. Default: 50. Max: 1000.",
                        "default": 50
                    },
                    "crawlWebsites": {
                        "title": "Enrich with website data (emails & social)",
                        "type": "boolean",
                        "description": "When enabled, visits each business website to extract email addresses and social media links. Recommended — this is what makes leads actionable. Disable only if you need only phone/address data faster.",
                        "default": true
                    },
                    "includeSubpages": {
                        "title": "Crawl contact/about subpages",
                        "type": "boolean",
                        "description": "Also crawl /contact, /about, /team subpages for better email coverage. Slower but finds more emails.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for scraping. Datacenter proxies (default) work for most sites. Use Residential if you experience blocks.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
