# 🎯 Sales Intelligence MCP (`nexgendata/sales-intelligence-mcp`) Actor

MCP server bundling 10 lead-generation and enrichment actors as AI-agent tools — a pay-per-result alternative to Apollo, ZoomInfo and Clay. Works with Claude Desktop, Cursor, n8n and any MCP-compatible client. No seats, no contracts, no quotas.

- **URL**: https://apify.com/nexgendata/sales-intelligence-mcp.md
- **Developed by:** [Stephan Corbeil](https://apify.com/nexgendata) (community)
- **Categories:** Lead generation, AI, Business
- **Stats:** 0 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $8,000.00 / 1,000 sales intelligence tool calls

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

## Sales Intelligence MCP — B2B Lead Gen for AI Agents

One MCP endpoint. Ten lead-gen + enrichment tools. Drop it into Claude Desktop, Cursor, Cline, or any agent that speaks the Model Context Protocol — and your AI assistant suddenly has the prospecting power of Apollo, ZoomInfo, Clearbit, and Lusha combined, billed per call instead of per seat.

This MCP server bundles 10 production NexGenData actors behind a single streamable-HTTP MCP transport. Your agent calls `find_company_emails("stripe.com")` or `find_b2b_leads(industry="fintech", country="Singapore")` and gets clean JSON back. No API keys to juggle, no rate-limit headaches, no $1,000/month Apollo seat that one analyst uses twice a week.

### Who This Is For

- **AI-powered SDR tooling** — give your sales agent the ability to research, qualify, and enrich prospects autonomously.
- **Founders building lead-gen automations** — replace a four-vendor sales stack (Apollo + ZoomInfo + Wappalyzer + Crunchbase Pro) with one MCP server.
- **Sales engineers + RevOps** — drop into Cursor and let Claude write enrichment loops over your CRM exports.
- **AI agent frameworks** — LangChain, Autogen, CrewAI, Smolagents users who want sales-intelligence tools that just work.

### The 10 Tools

| Tool | What it does | Upstream actor |
|---|---|---|
| `find_company_emails(domain)` | Discover role-based + verified business emails for a domain | [`nexgendata/company-email-finder`](https://apify.com/nexgendata/company-email-finder?fpr=2ayu9b) |
| `enrich_company(domain_or_name)` | Enrich one company with domain, industry, employees, socials, emails | [`nexgendata/company-enrichment-tool`](https://apify.com/nexgendata/company-enrichment-tool?fpr=2ayu9b) |
| `aggregate_company_profile(name, include_funding=True)` | Full company profile aggregated from homepage + /about + /careers + Crunchbase + JSON-LD | [`nexgendata/company-data-aggregator`](https://apify.com/nexgendata/company-data-aggregator?fpr=2ayu9b) |
| `find_b2b_leads(industry, country, employee_band, limit)` | Discover B2B leads matching industry / geo / size filters | [`nexgendata/b2b-leads-finder`](https://apify.com/nexgendata/b2b-leads-finder?fpr=2ayu9b) |
| `enrich_lead_list(domains)` | Bulk-enrich a list of domains with contact + social data | [`nexgendata/lead-list-enricher`](https://apify.com/nexgendata/lead-list-enricher?fpr=2ayu9b) |
| `detect_hiring_signal(company_slugs)` | Detect hiring momentum (open roles, growth keywords, scaling signals) for target accounts | [`nexgendata/hiring-signal-detector`](https://apify.com/nexgendata/hiring-signal-detector?fpr=2ayu9b) |
| `track_startup_funding(stage, sector, days_back)` | Track recent funding rounds filtered by stage / sector / lookback window | [`nexgendata/startup-funding-tracker`](https://apify.com/nexgendata/startup-funding-tracker?fpr=2ayu9b) |
| `detect_tech_stack(domain)` | Detect website tech stack — frameworks, CMS, analytics, payment, hosting, marketing tools (Wappalyzer replacement) | [`nexgendata/wappalyzer-replacement`](https://apify.com/nexgendata/wappalyzer-replacement?fpr=2ayu9b) |
| `find_yc_companies(batch, stage)` | Browse Y Combinator directory by batch (W26, S25, …) and status | [`nexgendata/yc-companies-directory-scraper`](https://apify.com/nexgendata/yc-companies-directory-scraper?fpr=2ayu9b) |
| `search_linkedin_jobs(query, location, posted_within_days)` | Search LinkedIn for public job postings with title + company + posted date + description | [`nexgendata/linkedin-jobs-scraper`](https://apify.com/nexgendata/linkedin-jobs-scraper?fpr=2ayu9b) |

Every tool returns structured JSON wrapped in MCP's `structuredContent` envelope so agents can reason about it without an additional parsing step.

### Connecting From Your MCP Client

The server runs in Apify Standby mode at:

````

https://nexgendata--sales-intelligence-mcp.apify.actor/mcp

````

You need an Apify token (free signup — credits included). Grab it from [Apify Console → Settings → Integrations](https://console.apify.com/account/integrations).

#### Claude Desktop (`claude_desktop_config.json`)

```json
{
  "mcpServers": {
    "sales-intelligence": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://nexgendata--sales-intelligence-mcp.apify.actor/mcp",
        "--header",
        "Authorization: Bearer YOUR_APIFY_TOKEN"
      ]
    }
  }
}
````

#### Cursor (`~/.cursor/mcp.json`)

```json
{
  "mcpServers": {
    "sales-intelligence": {
      "url": "https://nexgendata--sales-intelligence-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

#### Cline / Windsurf / Continue.dev

Use the same `streamable-http` transport. Point the client at the URL above with an `Authorization: Bearer …` header. Cline's MCP settings UI takes the URL and headers verbatim.

#### Python (raw FastMCP client)

```python
from fastmcp import Client

async def main():
    headers = {"Authorization": "Bearer YOUR_APIFY_TOKEN"}
    async with Client(
        "https://nexgendata--sales-intelligence-mcp.apify.actor/mcp",
        headers=headers,
    ) as c:
        result = await c.call_tool("find_company_emails", {"domain": "stripe.com"})
        print(result.structured_content)
```

### Example Agent Workflows

#### Workflow 1 — "Find 10 fintech companies in Singapore with hiring momentum and verified emails"

```
1. find_b2b_leads(industry="fintech", country="Singapore", limit=10)
       -> list of 10 fintech company domains in SG
2. detect_hiring_signal(company_slugs=[...10 slugs...])
       -> filter to ones with open roles or growth signals
3. enrich_lead_list(domains=[...filtered...])
       -> add verified emails, social profiles, contact pages
```

One natural-language prompt to your agent, three MCP tool calls, ~$1.20 in PPE charges, a contact-ready list of qualified leads. The equivalent workflow on Apollo + LinkedIn Sales Navigator is a $400/month minimum spend and 30+ minutes of UI clicking.

#### Workflow 2 — "Enrich this list of 100 domains with contact + funding data"

```
1. enrich_lead_list(domains=[…100 domains…])
       -> emails + social profiles + contact pages
2. for batch of 10:
       aggregate_company_profile(name, include_funding=True)
       -> industry + HQ + employee band + funding history + key people
```

Total cost: ~$11 for the full enrichment of 100 companies. ZoomInfo lookup tier comparable cost: $1,500+/month seat minimum.

#### Workflow 3 — "Track YC W26 batch + their tech stacks"

```
1. find_yc_companies(batch="W26")
       -> 50 freshly funded YC companies
2. for each company:
       detect_tech_stack(company.website)
       -> framework, CMS, analytics, payment, hosting
```

Perfect for devtool / DevRel teams who need to know what stack the latest cohort is building on. Total cost: ~$2.55 for 50 stack detections.

#### Workflow 4 — "Find AI startups that raised in the last 30 days and are hiring engineers"

```
1. track_startup_funding(sector="ai", days_back=30)
       -> list of recently funded AI startups
2. detect_hiring_signal(company_slugs=[...names...])
       -> filter to ones actively hiring engineers
3. find_company_emails(domain=...)
       -> for the top 20, fetch outreach addresses
```

### Pricing — Pay Only For What You Call

We use Apify's pay-per-event (PPE) billing. Three events, transparent rates:

| Event | Price | When it fires |
|---|---|---|
| `apify-actor-start` | **$0.01** | Once per MCP session (system event — fires when your client connects) |
| `tool-call` | **$0.05** | Every successful tool invocation |
| `enrichment-tier` | **$0.10** | When the tool returns enrichment data (emails / phones / profiles / funding) — fires for `find_company_emails`, `enrich_company`, `aggregate_company_profile`, `find_b2b_leads`, `enrich_lead_list`, `track_startup_funding` |

**Typical session math:**

- *Quick lookup* (one `find_company_emails` call): `0.01 + 0.05 + 0.10 = $0.16`
- *Standard prospecting* (5 tool calls, 3 enrichment): `0.01 + 5×0.05 + 3×0.10 = $0.56`
- *Heavy enrichment* (10 calls, 8 enrichment): `0.01 + 10×0.05 + 8×0.10 = $1.31`
- *Bulk run* (50 calls, 40 enrichment): `0.01 + 50×0.05 + 40×0.10 = $6.51`

You only pay when a call succeeds and returns data — failed lookups don't charge the enrichment tier.

### Why This Beats The Incumbents

| Vendor | Entry price | Per-lookup cost | Bring-your-own-agent? | Coverage |
|---|---|---|---|---|
| Apollo.io | $99–$299/mo seat | $0.10–$0.30 per credit | Limited API | Contacts + companies |
| ZoomInfo | $14,995/yr seat | $0.30+ per record | Enterprise API only | Contacts + intent |
| Clearbit (HubSpot) | Enterprise quote | $0.50+ per enrichment | API yes, no MCP | Company + person |
| Lusha | $69+/mo seat | $0.10–$0.40 per credit | Limited API | Contacts only |
| Hunter.io | $49+/mo | $0.05 per find | API yes, no MCP | Emails only |
| Wappalyzer (RIP) | Was $149/mo | Subscription discontinued | n/a — service ended | Tech stack |
| **Sales Intelligence MCP** | **$0** (PPE only) | **$0.05–$0.15 per call** | **YES — MCP-native** | **All 10 use cases above** |

Three things make this different:

1. **MCP-native** — your AI agent calls the tools directly, not you clicking through a UI.
2. **Per-call billing** — no minimum, no seat, no 12-month contract. Run it once a week or 1,000 times a day.
3. **Composable** — chain the 10 tools in any order. Find → enrich → qualify → outreach, all inside one agent loop.

### Don't Have an Apify Account?

[**Sign up free**](https://www.apify.com/sign-up?fpr=2ayu9b) — you get platform credits on signup, and signing up via that link helps fund continued development of this fleet (we get a small affiliate cut, no extra cost to you).

### Sister Actors

Use these alongside the MCP server, or hit them directly via the Apify API / SDK / Zapier / Make.com / n8n:

- [Company Email Finder](https://apify.com/nexgendata/company-email-finder?fpr=2ayu9b) — bulk role-based + verified emails
- [Company Enrichment Tool](https://apify.com/nexgendata/company-enrichment-tool?fpr=2ayu9b) — per-company enrichment
- [Company Data Aggregator](https://apify.com/nexgendata/company-data-aggregator?fpr=2ayu9b) — homepage + Crunchbase + JSON-LD aggregator
- [B2B Lead Finder](https://apify.com/nexgendata/b2b-leads-finder?fpr=2ayu9b) — multi-source B2B prospect discovery
- [Lead List Enricher](https://apify.com/nexgendata/lead-list-enricher?fpr=2ayu9b) — bulk enrichment over domain lists
- [Hiring Signal Detector](https://apify.com/nexgendata/hiring-signal-detector?fpr=2ayu9b) — open-roles + growth-keyword scanner
- [Startup Funding Tracker](https://apify.com/nexgendata/startup-funding-tracker?fpr=2ayu9b) — Crunchbase News + TechCrunch funding feed
- [Wappalyzer Replacement](https://apify.com/nexgendata/wappalyzer-replacement?fpr=2ayu9b) — drop-in tech-stack detector
- [YC Directory Scraper](https://apify.com/nexgendata/yc-companies-directory-scraper?fpr=2ayu9b) — full YC company directory
- [LinkedIn Jobs Scraper](https://apify.com/nexgendata/linkedin-jobs-scraper?fpr=2ayu9b) — public job-posting search

### FAQ

**Q: Do I need a separate Apify account for each upstream actor?**
No. One Apify token unlocks all 10 tools through the MCP server. The server orchestrates everything server-side using `Actor.call(...)`.

**Q: Can I use this in production agent workflows?**
Yes. Apify Standby mode keeps a warm container ready for incoming MCP sessions, with auto-scaling on the platform side. Tool calls are billed only on success, so retries don't double-charge.

**Q: What's the typical latency?**
Tool calls range from 5s (cached enrichment) to ~120s (LinkedIn jobs with full descriptions, full YC batch dump). Most calls land in the 15-45s range. The MCP transport keeps the connection open while the upstream runs.

**Q: Can I extend it with my own tools?**
The source is open in the actor — fork it on Apify, add tools, redeploy under your own namespace. The pattern is FastMCP `@server.tool()` decorators wrapping `Actor.call(...)`.

**Q: Is the upstream data quality good enough for outbound?**
Yes — these are the same actors used by ~400 paying NexGenData customers across 11 lead-gen actors. Email patterns are verified via DNS MX records; enrichment includes confidence scores where applicable.

***

*Built and maintained by [NexGenData](https://apify.com/nexgendata?fpr=2ayu9b) — 165+ actors covering scraping, enrichment, MCP servers, and automation.*

Home: [thenextgennexus.com](https://thenextgennexus.com)

# Actor input Schema

## Actor input object example

```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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/sales-intelligence-mcp").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/sales-intelligence-mcp").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 '{}' |
apify call nexgendata/sales-intelligence-mcp --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🎯 Sales Intelligence MCP",
        "description": "MCP server bundling 10 lead-generation and enrichment actors as AI-agent tools — a pay-per-result alternative to Apollo, ZoomInfo and Clay. Works with Claude Desktop, Cursor, n8n and any MCP-compatible client. No seats, no contracts, no quotas.",
        "version": "0.0",
        "x-build-id": "S4lLtQB2HgggRk10W"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~sales-intelligence-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-sales-intelligence-mcp",
                "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/nexgendata~sales-intelligence-mcp/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-sales-intelligence-mcp",
                "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/nexgendata~sales-intelligence-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-sales-intelligence-mcp",
                "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": {}
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
