# LeadGraph (AI B2B Lead Generation & ICP Scoring) (`antoniovfranco/leadgraph`) Actor

AI-powered B2B lead generation with LangGraph ICP scoring, knowledge graph, and trigger signals. Scrapes LinkedIn, HackerNews, Google Maps and Apollo. Scores leads against your ICP using Groq (free) or OpenAI.

- **URL**: https://apify.com/antoniovfranco/leadgraph.md
- **Developed by:** [Antonio V. Franco](https://apify.com/antoniovfranco) (community)
- **Categories:** Lead generation, AI, Automation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 scored leads

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



# Actor input Schema

## `sources` (type: `array`):

One or more sources to scrape leads from. Each object must have a 'type' field: 'linkedin', 'google_maps', 'hackernews', or 'apollo'. Example: [{"type":"hackernews","query":"who is hiring","postTypes":["hiring"]}]
## `icpConfig` (type: `object`):

Define your target customer profile. All fields optional — leave empty to score all leads.
## `triggerTypes` (type: `array`):

Which intent signals to detect and add score bonus for.
## `maxLeads` (type: `integer`):

Maximum number of scored leads to push to the dataset (PPE billing cap).
## `enrichmentLevel` (type: `string`):

basic = no external API calls; standard = Clearbit company data; full = Clearbit + funding + open jobs.
## `groqApiKey` (type: `string`):

Free LLM scoring via Groq (llama-3.3-70b-versatile). Get your key at console.groq.com. Takes priority over OpenAI if both are set.
## `groqModel` (type: `string`):

Groq model to use for ICP scoring.
## `openaiApiKey` (type: `string`):

OpenAI key for ICP scoring. Only used if groqApiKey is not set.
## `openaiModel` (type: `string`):

OpenAI model. Only used if groqApiKey is not set.
## `proxyConfig` (type: `object`):

Proxy settings for scraping. Residential proxies recommended for LinkedIn.
## `apolloApiKey` (type: `string`):

Required only if using the Apollo source.
## `clearbitApiKey` (type: `string`):

Required for enrichmentLevel=standard or full.
## `hunterApiKey` (type: `string`):

Optional. Used to verify email deliverability.
## `icpDocuments` (type: `array`):

Optional. Paste free-text documents describing your ideal customer — product descriptions, customer success stories, examples of great and poor fits, pitch deck copy, etc. Each array item is one document. LeadGraph will chunk and retrieve the most relevant context for each lead, injecting it into the AI scoring prompt for personalised, company-specific evaluation. Requires at least one LLM key (groqApiKey or openaiApiKey). For vector search instead of LLM re-ranking, also provide openaiApiKey.
## `icpFiles` (type: `array`):

Upload PDF, DOCX, TXT, MD, or image files (PNG, JPG, WEBP) that describe your ideal customer — pitch decks, case studies, customer profiles, org charts, screenshots, etc. Text is extracted locally at no cost (PDF and DOCX via open-source libraries). Images require your openaiApiKey: the Actor uses GPT-4o-mini Vision charged to your own OpenAI account. Without the key, images are skipped with a warning. Extracted text is merged with any ICP Documents above before scoring.
## `ragTopK` (type: `integer`):

Number of ICP document chunks retrieved and injected into the scoring prompt per lead. Higher values = more context but more tokens. Default: 3.
## `ragEvalEnabled` (type: `boolean`):

When true, computes RAGAS-inspired metrics at the end of the run (context relevance, faithfulness, ICP coverage) and pushes them to the Dataset. Useful for tuning your ICP documents. Automatically enabled when icpDocuments is provided.

## Actor input object example

```json
{
  "sources": [
    {
      "type": "hackernews",
      "query": "who is hiring",
      "postTypes": [
        "hiring"
      ]
    }
  ],
  "icpConfig": {
    "sectors": [
      "saas",
      "fintech",
      "devtools"
    ],
    "companySizeRange": {
      "min": 10,
      "max": 500
    },
    "targetRoles": [
      "CTO",
      "VP Engineering",
      "Head of Product",
      "Engineering Manager"
    ],
    "keywords": [
      "api",
      "cloud",
      "kubernetes",
      "microservices"
    ],
    "locations": [
      "United States",
      "Brazil",
      "Europe"
    ],
    "techStack": [
      "React",
      "Node.js",
      "Postgres",
      "AWS"
    ],
    "excludedSectors": [
      "gaming",
      "consumer"
    ]
  },
  "triggerTypes": [
    "funding",
    "hiring",
    "content"
  ],
  "maxLeads": 200,
  "enrichmentLevel": "standard",
  "groqModel": "llama-3.3-70b-versatile",
  "openaiModel": "gpt-4o-mini",
  "proxyConfig": {
    "useApifyProxy": true
  },
  "icpDocuments": [
    "Our product helps B2B SaaS companies automate outbound sales. Our best customers are VP of Sales and Head of Growth at Series A–C companies with 20–200 employees, typically in the US or Europe. They use tools like Salesforce, HubSpot, Outreach, and Apollo. Key pain point: their SDRs spend 60% of time on manual research instead of conversations.",
    "Companies that are a poor fit: consumer apps, gaming, agencies, non-profits, or companies with fewer than 10 employees. Also avoid companies where the primary buyer is a CEO at very early stage — they rarely have budget."
  ],
  "ragTopK": 3,
  "ragEvalEnabled": true
}
````

# 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 = {
    "sources": [
        {
            "type": "hackernews",
            "query": "who is hiring",
            "postTypes": [
                "hiring"
            ]
        }
    ],
    "icpConfig": {
        "sectors": [
            "saas",
            "fintech",
            "devtools"
        ],
        "companySizeRange": {
            "min": 10,
            "max": 500
        },
        "targetRoles": [
            "CTO",
            "VP Engineering",
            "Head of Product",
            "Engineering Manager"
        ],
        "keywords": [
            "api",
            "cloud",
            "kubernetes",
            "microservices"
        ],
        "locations": [
            "United States",
            "Brazil",
            "Europe"
        ],
        "techStack": [
            "React",
            "Node.js",
            "Postgres",
            "AWS"
        ],
        "excludedSectors": [
            "gaming",
            "consumer"
        ]
    },
    "triggerTypes": [
        "funding",
        "hiring",
        "content"
    ],
    "maxLeads": 200,
    "enrichmentLevel": "standard",
    "groqModel": "llama-3.3-70b-versatile",
    "openaiModel": "gpt-4o-mini",
    "proxyConfig": {
        "useApifyProxy": true
    },
    "icpDocuments": [
        "Our product helps B2B SaaS companies automate outbound sales. Our best customers are VP of Sales and Head of Growth at Series A–C companies with 20–200 employees, typically in the US or Europe. They use tools like Salesforce, HubSpot, Outreach, and Apollo. Key pain point: their SDRs spend 60% of time on manual research instead of conversations.",
        "Companies that are a poor fit: consumer apps, gaming, agencies, non-profits, or companies with fewer than 10 employees. Also avoid companies where the primary buyer is a CEO at very early stage — they rarely have budget."
    ],
    "ragTopK": 3,
    "ragEvalEnabled": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("antoniovfranco/leadgraph").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 = {
    "sources": [{
            "type": "hackernews",
            "query": "who is hiring",
            "postTypes": ["hiring"],
        }],
    "icpConfig": {
        "sectors": [
            "saas",
            "fintech",
            "devtools",
        ],
        "companySizeRange": {
            "min": 10,
            "max": 500,
        },
        "targetRoles": [
            "CTO",
            "VP Engineering",
            "Head of Product",
            "Engineering Manager",
        ],
        "keywords": [
            "api",
            "cloud",
            "kubernetes",
            "microservices",
        ],
        "locations": [
            "United States",
            "Brazil",
            "Europe",
        ],
        "techStack": [
            "React",
            "Node.js",
            "Postgres",
            "AWS",
        ],
        "excludedSectors": [
            "gaming",
            "consumer",
        ],
    },
    "triggerTypes": [
        "funding",
        "hiring",
        "content",
    ],
    "maxLeads": 200,
    "enrichmentLevel": "standard",
    "groqModel": "llama-3.3-70b-versatile",
    "openaiModel": "gpt-4o-mini",
    "proxyConfig": { "useApifyProxy": True },
    "icpDocuments": [
        "Our product helps B2B SaaS companies automate outbound sales. Our best customers are VP of Sales and Head of Growth at Series A–C companies with 20–200 employees, typically in the US or Europe. They use tools like Salesforce, HubSpot, Outreach, and Apollo. Key pain point: their SDRs spend 60% of time on manual research instead of conversations.",
        "Companies that are a poor fit: consumer apps, gaming, agencies, non-profits, or companies with fewer than 10 employees. Also avoid companies where the primary buyer is a CEO at very early stage — they rarely have budget.",
    ],
    "ragTopK": 3,
    "ragEvalEnabled": True,
}

# Run the Actor and wait for it to finish
run = client.actor("antoniovfranco/leadgraph").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 '{
  "sources": [
    {
      "type": "hackernews",
      "query": "who is hiring",
      "postTypes": [
        "hiring"
      ]
    }
  ],
  "icpConfig": {
    "sectors": [
      "saas",
      "fintech",
      "devtools"
    ],
    "companySizeRange": {
      "min": 10,
      "max": 500
    },
    "targetRoles": [
      "CTO",
      "VP Engineering",
      "Head of Product",
      "Engineering Manager"
    ],
    "keywords": [
      "api",
      "cloud",
      "kubernetes",
      "microservices"
    ],
    "locations": [
      "United States",
      "Brazil",
      "Europe"
    ],
    "techStack": [
      "React",
      "Node.js",
      "Postgres",
      "AWS"
    ],
    "excludedSectors": [
      "gaming",
      "consumer"
    ]
  },
  "triggerTypes": [
    "funding",
    "hiring",
    "content"
  ],
  "maxLeads": 200,
  "enrichmentLevel": "standard",
  "groqModel": "llama-3.3-70b-versatile",
  "openaiModel": "gpt-4o-mini",
  "proxyConfig": {
    "useApifyProxy": true
  },
  "icpDocuments": [
    "Our product helps B2B SaaS companies automate outbound sales. Our best customers are VP of Sales and Head of Growth at Series A–C companies with 20–200 employees, typically in the US or Europe. They use tools like Salesforce, HubSpot, Outreach, and Apollo. Key pain point: their SDRs spend 60% of time on manual research instead of conversations.",
    "Companies that are a poor fit: consumer apps, gaming, agencies, non-profits, or companies with fewer than 10 employees. Also avoid companies where the primary buyer is a CEO at very early stage — they rarely have budget."
  ],
  "ragTopK": 3,
  "ragEvalEnabled": true
}' |
apify call antoniovfranco/leadgraph --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LeadGraph (AI B2B Lead Generation & ICP Scoring)",
        "description": "AI-powered B2B lead generation with LangGraph ICP scoring, knowledge graph, and trigger signals. Scrapes LinkedIn, HackerNews, Google Maps and Apollo. Scores leads against your ICP using Groq (free) or OpenAI.",
        "version": "1.0",
        "x-build-id": "BOo36yhXHBQYcBI8G"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/antoniovfranco~leadgraph/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-antoniovfranco-leadgraph",
                "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/antoniovfranco~leadgraph/runs": {
            "post": {
                "operationId": "runs-sync-antoniovfranco-leadgraph",
                "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/antoniovfranco~leadgraph/run-sync": {
            "post": {
                "operationId": "run-sync-antoniovfranco-leadgraph",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "sources",
                    "icpConfig"
                ],
                "properties": {
                    "sources": {
                        "title": "Data Sources",
                        "type": "array",
                        "description": "One or more sources to scrape leads from. Each object must have a 'type' field: 'linkedin', 'google_maps', 'hackernews', or 'apollo'. Example: [{\"type\":\"hackernews\",\"query\":\"who is hiring\",\"postTypes\":[\"hiring\"]}]"
                    },
                    "icpConfig": {
                        "title": "Ideal Customer Profile (ICP)",
                        "type": "object",
                        "description": "Define your target customer profile. All fields optional — leave empty to score all leads."
                    },
                    "triggerTypes": {
                        "title": "Trigger Signal Types",
                        "type": "array",
                        "description": "Which intent signals to detect and add score bonus for."
                    },
                    "maxLeads": {
                        "title": "Max Leads",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of scored leads to push to the dataset (PPE billing cap)."
                    },
                    "enrichmentLevel": {
                        "title": "Enrichment Level",
                        "enum": [
                            "basic",
                            "standard",
                            "full"
                        ],
                        "type": "string",
                        "description": "basic = no external API calls; standard = Clearbit company data; full = Clearbit + funding + open jobs."
                    },
                    "groqApiKey": {
                        "title": "Groq API Key (recommended — free tier)",
                        "type": "string",
                        "description": "Free LLM scoring via Groq (llama-3.3-70b-versatile). Get your key at console.groq.com. Takes priority over OpenAI if both are set."
                    },
                    "groqModel": {
                        "title": "Groq Model",
                        "enum": [
                            "llama-3.3-70b-versatile",
                            "llama3-8b-8192",
                            "mixtral-8x7b-32768"
                        ],
                        "type": "string",
                        "description": "Groq model to use for ICP scoring."
                    },
                    "openaiApiKey": {
                        "title": "OpenAI API Key (optional fallback)",
                        "type": "string",
                        "description": "OpenAI key for ICP scoring. Only used if groqApiKey is not set."
                    },
                    "openaiModel": {
                        "title": "OpenAI Model",
                        "enum": [
                            "gpt-4o-mini",
                            "gpt-4o",
                            "gpt-4-turbo"
                        ],
                        "type": "string",
                        "description": "OpenAI model. Only used if groqApiKey is not set."
                    },
                    "proxyConfig": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for scraping. Residential proxies recommended for LinkedIn."
                    },
                    "apolloApiKey": {
                        "title": "Apollo.io API Key",
                        "type": "string",
                        "description": "Required only if using the Apollo source."
                    },
                    "clearbitApiKey": {
                        "title": "Clearbit API Key",
                        "type": "string",
                        "description": "Required for enrichmentLevel=standard or full."
                    },
                    "hunterApiKey": {
                        "title": "Hunter.io API Key",
                        "type": "string",
                        "description": "Optional. Used to verify email deliverability."
                    },
                    "icpDocuments": {
                        "title": "ICP Documents (RAG)",
                        "type": "array",
                        "description": "Optional. Paste free-text documents describing your ideal customer — product descriptions, customer success stories, examples of great and poor fits, pitch deck copy, etc. Each array item is one document. LeadGraph will chunk and retrieve the most relevant context for each lead, injecting it into the AI scoring prompt for personalised, company-specific evaluation. Requires at least one LLM key (groqApiKey or openaiApiKey). For vector search instead of LLM re-ranking, also provide openaiApiKey."
                    },
                    "icpFiles": {
                        "title": "ICP Files — upload documents & images (RAG)",
                        "type": "array",
                        "description": "Upload PDF, DOCX, TXT, MD, or image files (PNG, JPG, WEBP) that describe your ideal customer — pitch decks, case studies, customer profiles, org charts, screenshots, etc. Text is extracted locally at no cost (PDF and DOCX via open-source libraries). Images require your openaiApiKey: the Actor uses GPT-4o-mini Vision charged to your own OpenAI account. Without the key, images are skipped with a warning. Extracted text is merged with any ICP Documents above before scoring.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ragTopK": {
                        "title": "RAG Top-K (chunks per lead)",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of ICP document chunks retrieved and injected into the scoring prompt per lead. Higher values = more context but more tokens. Default: 3."
                    },
                    "ragEvalEnabled": {
                        "title": "Enable RAGAS Evaluation",
                        "type": "boolean",
                        "description": "When true, computes RAGAS-inspired metrics at the end of the run (context relevance, faithfulness, ICP coverage) and pushes them to the Dataset. Useful for tuning your ICP documents. Automatically enabled when icpDocuments is provided."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
