# B2B Lead Qualifier: Google Maps + Tech Stack Intelligence (`conversational_kermis/lead-qualifier`) Actor

Find businesses on Google Maps, scan their websites for missing technology (booking, ecommerce, chat, email marketing, payments), and score them as qualified B2B leads. Tell it what you sell and who to search — get a scored prospect list with buying signals. $0.01/lead.

- **URL**: https://apify.com/conversational\_kermis/lead-qualifier.md
- **Developed by:** [the anh nguyen](https://apify.com/conversational_kermis) (community)
- **Categories:** Lead generation, E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## B2B Lead Qualifier: Google Maps + Tech Stack Intelligence

Find businesses on Google Maps and instantly know which ones are missing the software you sell.

**Stop cold-calling blind.** This actor searches Google Maps for any business type in any location, scans each website for 160+ technologies across 16 categories, benchmarks every business against their local competitors, and generates outreach-ready talking points. $0.01/lead.

### What it does

1. **Finds businesses** — Searches Google Maps for your target vertical (nail salons, restaurants, dental clinics, yoga studios...)
2. **Scans websites** — Detects 160+ technologies: CMS, booking, e-commerce, analytics, chat, email marketing, payments, ad pixels, CRM, and more
3. **Extracts contact intel** — Finds social media profiles (Facebook, Instagram, LinkedIn...), email addresses, and phone numbers
4. **Benchmarks competitors** — Shows what % of similar businesses in the area use each technology
5. **Scores leads** — Ranks businesses by what they're *missing*, weighted by what you're selling
6. **Generates talking points** — Ready-to-use outreach bullets per lead, personalized to their gaps

### Example output

```json
{
    "leadScore": 82,
    "leadTier": "hot",
    "name": "Nail Studio Praha",
    "phone": "+420 123 456 789",
    "website": "https://nailstudiopraha.cz",
    "rating": 4.6,
    "reviewCount": 234,
    "priceLevel": 2,
    "talkingPoints": [
        "Nail Studio Praha has a strong reputation (4.6/5, 234 reviews) but gaps in their digital stack",
        "No online booking detected — customers likely book by phone. Only 23% of competitors offer it",
        "23% of similar businesses already use online booking — Nail Studio Praha risks falling behind"
    ],
    "buyingSignals": [
        "No online booking system — likely manages appointments by phone or walk-in",
        "No email marketing tools — not nurturing customer relationships digitally",
        "High-rated business (4.6/5, 234 reviews) — likely profitable, can afford tools",
        "Most competitors (67%) already use web analytics — falling behind"
    ],
    "socialPresence": {
        "facebook": "https://facebook.com/nailstudiopraha",
        "instagram": "https://instagram.com/nailstudiopraha",
        "linkedin": null,
        "youtube": null,
        "tiktok": null,
        "twitter": null,
        "pinterest": null
    },
    "contactMethods": {
        "email": "info@nailstudiopraha.cz",
        "phone": "+420123456789",
        "contactForm": true,
        "liveChat": false
    },
    "marketContext": {
        "booking": {"adoptionRate": 23, "topTools": ["Reservio", "Calendly"], "businessesWithIt": 12, "businessesTotal": 52},
        "analytics": {"adoptionRate": 67, "topTools": ["Google Analytics", "GTM"], "businessesWithIt": 35, "businessesTotal": 52}
    },
    "techStack": {
        "cms": ["WordPress"],
        "booking": [],
        "analytics": ["Google Analytics"],
        "chat": [],
        "emailMarketing": [],
        "ecommerce": [],
        "payment": [],
        "adPixels": ["Google Ads"],
        "reviews": ["Google Reviews Widget"],
        "cookieConsent": [],
        "crm": [],
        "abTesting": [],
        "cdn": ["Cloudflare"],
        "errorTracking": [],
        "accessibility": [],
        "fonts": ["Google Fonts"]
    }
}
````

### Who is this for?

| You sell... | You get... |
|-------------|-----------|
| **Booking software** (Calendly, Booksy, Fresha) | Businesses with no online booking |
| **E-commerce platforms** (Shopify, WooCommerce) | Businesses not selling online |
| **Marketing automation** (Mailchimp, Klaviyo) | Businesses with no email marketing |
| **Website builders** (Wix, Squarespace, Webflow) | Businesses with outdated or no CMS |
| **Payment processors** (Stripe, Square) | Businesses not accepting online payments |
| **Live chat tools** (Intercom, Tidio, tawk.to) | Businesses with no chat widget |
| **Analytics platforms** (GA, Hotjar, Mixpanel) | Businesses not tracking conversions |
| **CRM systems** (HubSpot, Salesforce) | Businesses without CRM integration |

### Input options

#### Option 1: Search Google Maps (easiest)

Provide a business category and location. The actor calls the Google Maps scraper automatically.

```json
{
    "searchQuery": "nail salons",
    "location": "Prague",
    "maxPlaces": 50,
    "buyerPersona": "booking_software"
}
```

#### Option 2: Use existing data

Pass a dataset ID from a previous Google Maps scraper run.

```json
{
    "datasetId": "your-dataset-id-here",
    "buyerPersona": "ecommerce_platform"
}
```

#### Option 3: Manual URLs

Provide your own list of websites to analyze.

```json
{
    "urls": [
        {"url": "https://example-salon.com", "name": "Example Salon"},
        {"url": "https://another-business.cz", "name": "Another Business"}
    ],
    "buyerPersona": "general"
}
```

### Buyer personas

Choose what you're selling to optimize lead scoring:

- **Booking / Scheduling Software** — Highest weight on missing booking systems
- **E-commerce Platform** — Highest weight on missing online store + payments
- **Marketing & Email Automation** — Highest weight on missing email tools + analytics
- **Website Builder / CMS Upgrade** — Highest weight on missing or outdated CMS
- **Payment Processor** — Highest weight on missing payment processing
- **Live Chat / Chatbot** — Highest weight on missing chat widgets
- **Analytics Platform** — Highest weight on missing analytics tools
- **General** — All gaps weighted equally

### Lead scoring

Each lead gets a score from 0-100:

- **Hot (70-100):** Missing critical tech for your product — strong buying signal
- **Warm (40-69):** Some gaps — worth reaching out
- **Cold (0-39):** Already has most tools — lower priority

Scoring factors:

- **Missing technology** weighted by your buyer persona (primary driver)
- **Competitive benchmarks** — missing tech that most competitors have scores higher
- **Google Maps signals** — price level, photo count, claimed status, review quality
- **Website quality** — mobile-ready, structured data, SSL, social presence
- **Reservation URL override** — if Google Maps shows a booking link, booking is not flagged as missing

Use `minScore` to filter: set to 70 for hot leads only.

### Competitive benchmarking

Every lead includes market context showing how they compare to other businesses in the search:

- **Adoption rates** — what % of similar businesses use each technology category
- **Top tools** — the most popular tools in each category among competitors
- **Competitive signals** — "Most competitors (67%) already use web analytics — falling behind"

This turns generic gap analysis into data-backed sales ammunition.

### Technologies detected (160+)

| Category | Count | Examples |
|----------|-------|---------|
| CMS | 17 | WordPress, Wix, Squarespace, Shopify, Webflow, Joomla, Drupal, HubSpot CMS |
| Booking | 19 | Booksy, Fresha, Calendly, Acuity, SimplyBook, Mindbody, Reservio, Vagaro |
| Analytics | 16 | Google Analytics, GTM, Hotjar, Facebook Pixel, Clarity, Matomo, PostHog |
| Chat | 15 | Intercom, Tidio, LiveChat, Zendesk, tawk.to, Crisp, Smartsupp, Gorgias |
| Email Marketing | 12 | Mailchimp, Klaviyo, ConvertKit, ActiveCampaign, Brevo, MailerLite, Drip |
| E-commerce | 10 | WooCommerce, Shopify, Magento, BigCommerce, Shoptet, Upgates, Ecwid |
| Payments | 12 | Stripe, PayPal, Square, GoPay, Comgate, Klarna, Apple Pay, Adyen |
| Ad Pixels | 12 | Google Ads, TikTok Pixel, Pinterest Tag, LinkedIn Insight, Criteo, Taboola |
| A/B Testing | 6 | Optimizely, VWO, Google Optimize, AB Tasty, LaunchDarkly |
| CDN | 8 | Cloudflare, AWS CloudFront, Vercel, Netlify, Fastly, Akamai |
| CRM | 6 | HubSpot CRM, Salesforce, Zoho CRM, Pipedrive, Freshsales |
| Error Tracking | 6 | Sentry, LogRocket, Bugsnag, Datadog RUM, Rollbar |
| Accessibility | 5 | UserWay, AccessiBe, AudioEye, EqualWeb, Recite Me |
| Reviews | 7 | Trustpilot, Google Reviews, Yelp, Tripadvisor, Judge.me, Yotpo |
| Cookie Consent | 7 | CookieBot, OneTrust, CookieYes, Osano, Termly, Iubenda |
| Fonts | 5 | Google Fonts, Adobe Fonts, Font Awesome, Bootstrap Icons |

Includes CZ/SK-specific technologies: Reservio, Bookio, Reenio, GoPay, Comgate, ThePay, Shoptet, Upgates, Ecomail, SmartEmailing, Seznam Sklik.

### Social & contact intelligence

Every lead includes extracted social profiles and contact methods:

- **Social media:** Facebook, Instagram, LinkedIn, YouTube, TikTok, Twitter/X, Pinterest — actual profile URLs
- **Contact methods:** Email addresses, phone numbers, contact form detection, live chat detection
- **Website quality:** Mobile viewport, structured data (Schema.org), Open Graph tags, favicon

### Google Maps deep signals

When searching Google Maps, the actor also captures:

- **Price level** ($-$$$$) — indicates business sophistication and budget
- **Photo count** — correlates with marketing effort
- **Claimed status** — unclaimed listings suggest low digital maturity
- **Reservation URL** — pre-detects existing booking (prevents false positives)
- **Coordinates** — latitude/longitude for geographic analysis
- **Place ID** — stable Google identifier for deduplication

### Pricing

- **$0.01 per qualified lead** — includes tech stack analysis, scoring, benchmarking, contact intel, and talking points
- **$0.20 per Google Maps search** — covers the upstream Google Maps actor cost (skipped if you provide your own data)

**Example cost:** 50 nail salons in Prague = $0.20 (search) + 50 x $0.01 (leads) = **$0.70 total**

### Output

- **Dataset:** Four views — Qualified Leads, Outreach Ready (talking points + contacts), Contact Intelligence, Full Tech Stack Details
- **Report:** Markdown summary with market benchmark, technology gaps, contact intelligence, and hot leads (in Key-Value Store as `OUTPUT`)

# Actor input Schema

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

What type of business to search for (e.g., 'nail salons', 'dental clinics', 'yoga studios', 'restaurants').

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

City or region to search in (e.g., 'Prague', 'Austin, TX', 'London').

## `maxPlaces` (type: `integer`):

Maximum number of businesses to find from Google Maps. More places = higher cost (~$0.003/place from the Google Maps actor).

## `datasetId` (type: `string`):

Use an existing Apify dataset instead of searching Google Maps. The dataset must contain records with a 'website' or 'url' field.

## `urls` (type: `array`):

Manually provide website URLs to scan. Each item should be an object with at least a 'url' field, and optionally 'name', 'phone', 'address'.

## `buyerPersona` (type: `string`):

Your product category. This determines which missing technologies score highest as buying signals.

## `minScore` (type: `integer`):

Only output leads scoring at or above this threshold (0-100). Set to 70 for hot leads only.

## `concurrency` (type: `integer`):

How many websites to scan in parallel. Higher = faster but uses more memory.

## Actor input object example

```json
{
  "searchQuery": "nail salons",
  "location": "Prague",
  "maxPlaces": 50,
  "buyerPersona": "general",
  "minScore": 0,
  "concurrency": 5
}
```

# Actor output Schema

## `report` (type: `string`):

No description

## `dataset` (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 = {
    "searchQuery": "nail salons",
    "location": "Prague"
};

// Run the Actor and wait for it to finish
const run = await client.actor("conversational_kermis/lead-qualifier").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": "nail salons",
    "location": "Prague",
}

# Run the Actor and wait for it to finish
run = client.actor("conversational_kermis/lead-qualifier").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": "nail salons",
  "location": "Prague"
}' |
apify call conversational_kermis/lead-qualifier --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "B2B Lead Qualifier: Google Maps + Tech Stack Intelligence",
        "description": "Find businesses on Google Maps, scan their websites for missing technology (booking, ecommerce, chat, email marketing, payments), and score them as qualified B2B leads. Tell it what you sell and who to search — get a scored prospect list with buying signals. $0.01/lead.",
        "version": "1.2",
        "x-build-id": "Yv8g9iI0ECe3d0A4t"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/conversational_kermis~lead-qualifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-conversational_kermis-lead-qualifier",
                "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/conversational_kermis~lead-qualifier/runs": {
            "post": {
                "operationId": "runs-sync-conversational_kermis-lead-qualifier",
                "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/conversational_kermis~lead-qualifier/run-sync": {
            "post": {
                "operationId": "run-sync-conversational_kermis-lead-qualifier",
                "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": "Business Category",
                        "type": "string",
                        "description": "What type of business to search for (e.g., 'nail salons', 'dental clinics', 'yoga studios', 'restaurants')."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or region to search in (e.g., 'Prague', 'Austin, TX', 'London')."
                    },
                    "maxPlaces": {
                        "title": "Max Places",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of businesses to find from Google Maps. More places = higher cost (~$0.003/place from the Google Maps actor).",
                        "default": 50
                    },
                    "datasetId": {
                        "title": "Pre-scraped Dataset ID",
                        "type": "string",
                        "description": "Use an existing Apify dataset instead of searching Google Maps. The dataset must contain records with a 'website' or 'url' field."
                    },
                    "urls": {
                        "title": "Website URLs",
                        "type": "array",
                        "description": "Manually provide website URLs to scan. Each item should be an object with at least a 'url' field, and optionally 'name', 'phone', 'address'."
                    },
                    "buyerPersona": {
                        "title": "What Are You Selling?",
                        "enum": [
                            "booking_software",
                            "ecommerce_platform",
                            "marketing_automation",
                            "website_builder",
                            "payment_processor",
                            "chat_widget",
                            "analytics_platform",
                            "general"
                        ],
                        "type": "string",
                        "description": "Your product category. This determines which missing technologies score highest as buying signals.",
                        "default": "general"
                    },
                    "minScore": {
                        "title": "Minimum Lead Score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only output leads scoring at or above this threshold (0-100). Set to 70 for hot leads only.",
                        "default": 0
                    },
                    "concurrency": {
                        "title": "Scan Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many websites to scan in parallel. Higher = faster but uses more memory.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
