# B2b Lookalike Generator (`advantageous_subcontra/b2b-lookalike-generator`) Actor

Turns one seed company into a ranked list of "lookalike" businesses, with contact details for each. Under the hood it pipelines Google search, the Website Content Crawler, an LLM comparison, and the Contact Details Scraper.

- **URL**: https://apify.com/advantageous\_subcontra/b2b-lookalike-generator.md
- **Developed by:** [Fabian Maume](https://apify.com/advantageous_subcontra) (community)
- **Categories:** Lead generation, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 0.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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Lookalike Generator

### What does B2B Lookalike Generator do?

**B2B Lookalike Generator** turns one seed company into a ranked list of "lookalike" businesses **plus contact leads at each qualifying one**. Give it your own company's name and website, and it returns two datasets: a scored list of similar companies (0–100 similarity), and a set of enriched contact leads at the strongest matches, filtered to a target department (sales, marketing, C-suite, engineering, ...).

Under the hood it pipelines Google search, the [Website Content Crawler](https://apify.com/apify/website-content-crawler), an LLM comparison via the [Apify OpenRouter Actor](https://apify.com/apify/openrouter), and [vdrmota's Contact Info Scraper](https://apify.com/vdrmota/contact-info-scraper). Because it runs on the [Apify platform](https://apify.com) you get an API, scheduling, integrations, and result storage without hosting anything yourself.

### Why use B2B Lookalike Generator?

- **Outbound prospecting** — feed a single seed URL and get a decision-maker list in one Run. No LinkedIn scraping, no CRM cross-referencing.
- **Total addressable market sizing** — see who else sells to your customers and how many of them there are.
- **Account-based marketing** — build a warm target account list, pre-annotated with the LLM's similarity reasoning so reps understand *why* each account is on the list.
- **Competitor sales-team intelligence** — target the sales orgs at your top competitors specifically by picking `"sales"` as the target department.

### How to use B2B Lookalike Generator

1. Open the Actor in Apify Console and click **Try for free**.
2. Fill in the **Company or product name** and **Reference website URL** on the Input tab.
3. Pick a **Target department** (default `Sales`) and set **Leads per company** (default `3`).
4. Optionally tune the **Filtering threshold** — competitors scored below this value are dropped before contact scraping.
5. Click **Start**. The Actor runs Google Search Scraper, Website Content Crawler, an LLM scoring step, and finally the contact scraper on every company that clears the threshold.
6. Open the **Dataset** tab for the scored competitors. Then open the `SUB_DATASETS` key-value record for a link to the **leads** dataset — the enriched decision-maker output.

### Input

The Actor takes a small JSON input:

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `companyName` | string | yes | — | Used to build the queries `"<name> alternative"` and `"vs <name>"`. |
| `websiteUrl` | string | yes | — | The reference product's homepage. Crawled once and used as the LLM baseline. |
| `maxPagesPerQuery` | integer | no | `10` | Number of Google SERP pages fetched per query. |
| `maxCompetitors` | integer | no | `200` | Cap on candidate URLs sent to the crawler after dedup and blocklist. |
| `openRouterModel` | string | no | `openai/gpt-4o-mini` | Any model available on the [Apify OpenRouter Actor](https://apify.com/apify/openrouter). |
| `filteringThreshold` | integer (0–100) | no | `60` | Competitors scored below this are dropped before contact scraping. `score: null` rows are always dropped. |
| `targetDepartment` | string enum | no | `sales` | Department to enrich leads from. One of: `c_suite`, `product`, `engineering_technical`, `design`, `education`, `finance`, `human_resources`, `information_technology`, `legal`, `marketing`, `medical_health`, `operations`, `sales`, `consulting`. |
| `leadsPerCompany` | integer (1–25) | no | `3` | Max enriched leads per qualifying company (passed as `maximumLeadsEnrichmentRecords`). |

> **Total cost cap is a Run option, not an input field.** Set **Max total charge** in the Apify Console when starting the Actor (Advanced → *Max total charge*), or pass `maxTotalChargeUsd` on `POST /v2/acts/{actorId}/runs`. The orchestrator reads that value at startup and splits it evenly across the four sub-Actor steps (search, crawl, LLM, contacts).

Example input:

```json
{
    "companyName": "Notion",
    "websiteUrl": "https://notion.so",
    "maxPagesPerQuery": 10,
    "maxCompetitors": 30,
    "filteringThreshold": 70,
    "targetDepartment": "sales",
    "leadsPerCompany": 3
}
````

### Output

The Actor produces **two datasets**:

#### 1. Scored competitors (default dataset)

One item per scored competitor, sorted by descending `score`. This is the same shape as the upstream [Competitor Finder](https://github.com/fmaume/competitor-finder) Actor:

```json
{
    "url": "https://www.coda.io/",
    "domain": "coda.io",
    "title": "Coda — the all-in-one collaborative workspace",
    "serpRank": 2,
    "serpQuery": "Notion alternative",
    "score": 88,
    "reasoning": "Coda targets the same knowledge-work audience with docs, databases, and automations in a single collaborative workspace.",
    "contentSnippet": "Coda brings words, data, and teams together..."
}
```

#### 2. Enriched leads (named dataset `leads-<runId>`)

One item per company that cleared the filtering threshold. Each row is a merged contact-info-scraper output enriched with the source competitor's score and reasoning:

```json
{
    "domain": "coda.io",
    "originalStartUrl": "https://www.coda.io/",
    "emails": ["press@coda.io", "sales@coda.io"],
    "phones": ["+1-415-555-0134"],
    "linkedIns": ["https://linkedin.com/company/coda-io"],
    "leadsEnrichment": [
        {
            "fullName": "Jane Doe",
            "email": "jane.doe@coda.io",
            "jobTitle": "VP of Sales",
            "linkedinProfile": "https://linkedin.com/in/janedoe"
        }
    ],
    "sourceCompetitor": {
        "domain": "coda.io",
        "url": "https://www.coda.io/",
        "score": 88,
        "reasoning": "Coda targets the same knowledge-work audience..."
    },
    "targetDepartment": "sales"
}
```

The dataset URL is exposed under the `SUB_DATASETS` key-value record — click through from the Run's Output tab.

You can download either dataset in JSON, HTML, CSV, or Excel from the Apify Console.

### Data table (leads dataset)

| Field | Meaning |
|---|---|
| `domain` | Registrable domain of the qualifying company. |
| `emails`, `phones`, `linkedIns` | Contact endpoints discovered on the company's pages. |
| `leadsEnrichment[]` | One object per person: `fullName`, `email`, `jobTitle`, `linkedinProfile`. |
| `sourceCompetitor.score` | The 0–100 similarity score assigned in Step 4 (LLM). |
| `sourceCompetitor.reasoning` | Short LLM justification for the score. |
| `targetDepartment` | Which department this Run enriched (matches your input). |

### Pricing / cost estimation

Costs come from four sub-Actors:

- **Google Search Scraper** — 4 queries × `maxPagesPerQuery` pages.
- **Website Content Crawler** — 1 reference page + `maxCompetitors` candidate pages, `maxCrawlDepth: 0`.
- **OpenRouter** — one chat completion per candidate.
- **vdrmota/contact-info-scraper** — pay-per-event (pages scraped + enriched leads + verified emails). Bounded per company by `maxRequestsPerStartUrl: 20`, `maxDepth: 1`, and `leadsPerCompany`.

Set **Max total charge** on the Run to hard-cap the total. The orchestrator reads that value and splits it evenly across the four cost-spending steps — each gets `maxTotalChargeUsd / 4`. Cumulative spend is tracked between steps; the next step throws before launch if the running total exceeds the cap. The LLM step also short-circuits once its share is projected to be hit (estimated from OpenRouter token usage, ±20% accuracy).

If **Max total charge** is left unset, the orchestrator runs uncapped and no cap is passed to sub-Actors.

### Tips & advanced options

- **Tune the filter, not the crawl cap.** Raise `filteringThreshold` (e.g. from `60` to `80`) rather than lowering `maxCompetitors` — you keep broad candidate discovery cheap in Steps 1–3 and only pay the contact-scraper price on high-confidence matches.
- Pick **`c_suite`** or **`sales`** for outbound; pick **`engineering_technical`** or **`product`** for competitive intelligence.
- Increase `maxPagesPerQuery` if the target product is well-established (more pages → deeper competitor coverage).
- Swap `openRouterModel` to `anthropic/claude-sonnet-4-5` for higher-quality reasoning at a higher cost.
- Domains from `wikipedia.org`, `capterra.com`, `g2.com`, and other review/directory sites are always filtered out.
- Each of the four steps gets exactly `maxTotalChargeUsd / 4`. If contact scraping dominates for your target audience, raise **Max total charge** so its slice is enough.

### FAQ, disclaimers, and support

**Is this legal?** Public web scraping is widely done in aggregate, but confirm with your legal team that your use case complies with the target sites' terms and applicable privacy law (GDPR, CCPA, etc.) before running at scale — especially since this Actor extracts personal contact data.

**Why is a competitor scored `null`?** Its page could not be fetched, or the LLM call failed. Those rows are always dropped before contact scraping.

**Why is the leads dataset smaller than the competitors dataset?** Only competitors with `score >= filteringThreshold` are sent to the contact scraper. Lower the threshold to include more companies (at higher cost).

**Where do I report an issue?** Open one from the Actor's **Issues** tab in Apify Console.

# Actor input Schema

## `companyName` (type: `string`):

The reference product's name. Used to build Google queries: "<name> alternative" and "vs <name>".

## `websiteUrl` (type: `string`):

The reference product's homepage. Crawled once and used as the baseline against which each candidate is scored.

## `maxPagesPerQuery` (type: `integer`):

Number of SERP pages fetched per query (each page ≈ 10 organic results).

## `maxCompetitors` (type: `integer`):

Cap on candidate URLs sent to the content crawler after deduplication and blocklist filtering. Higher-ranking SERP results are preferred.

## `openRouterModel` (type: `string`):

Model ID passed to the Apify OpenRouter Actor. See https://openrouter.ai/models for options.

## `filteringThreshold` (type: `integer`):

Only companies scored at or above this value move on to the contact-scraping step. Companies with score `null` (scoring failed) are always dropped.

## `targetDepartment` (type: `string`):

Department to enrich leads from at each qualifying company. Passed to vdrmota/contact-info-scraper as leadsEnrichmentDepartments.

## `leadsPerCompany` (type: `integer`):

Maximum number of enriched leads to fetch from each qualifying company. Passed as maximumLeadsEnrichmentRecords to the contact scraper.

## Actor input object example

```json
{
  "companyName": "Apify",
  "websiteUrl": "https://apify.com",
  "maxPagesPerQuery": 10,
  "maxCompetitors": 200,
  "openRouterModel": "openai/gpt-4o-mini",
  "filteringThreshold": 75,
  "targetDepartment": "sales",
  "leadsPerCompany": 1
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `subDatasets` (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 = {
    "companyName": "Apify",
    "websiteUrl": "https://apify.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("advantageous_subcontra/b2b-lookalike-generator").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 = {
    "companyName": "Apify",
    "websiteUrl": "https://apify.com",
}

# Run the Actor and wait for it to finish
run = client.actor("advantageous_subcontra/b2b-lookalike-generator").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 '{
  "companyName": "Apify",
  "websiteUrl": "https://apify.com"
}' |
apify call advantageous_subcontra/b2b-lookalike-generator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "B2b Lookalike Generator",
        "description": "Turns one seed company into a ranked list of \"lookalike\" businesses, with contact details for each. Under the hood it pipelines Google search, the Website Content Crawler, an LLM comparison, and the Contact Details Scraper.",
        "version": "0.0",
        "x-build-id": "LVEYwLkJKFZoDa55C"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/advantageous_subcontra~b2b-lookalike-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-advantageous_subcontra-b2b-lookalike-generator",
                "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/advantageous_subcontra~b2b-lookalike-generator/runs": {
            "post": {
                "operationId": "runs-sync-advantageous_subcontra-b2b-lookalike-generator",
                "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/advantageous_subcontra~b2b-lookalike-generator/run-sync": {
            "post": {
                "operationId": "run-sync-advantageous_subcontra-b2b-lookalike-generator",
                "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": [
                    "companyName",
                    "websiteUrl"
                ],
                "properties": {
                    "companyName": {
                        "title": "Company or product name",
                        "type": "string",
                        "description": "The reference product's name. Used to build Google queries: \"<name> alternative\" and \"vs <name>\"."
                    },
                    "websiteUrl": {
                        "title": "Reference website URL",
                        "type": "string",
                        "description": "The reference product's homepage. Crawled once and used as the baseline against which each candidate is scored."
                    },
                    "maxPagesPerQuery": {
                        "title": "Google pages per query",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of SERP pages fetched per query (each page ≈ 10 organic results).",
                        "default": 10
                    },
                    "maxCompetitors": {
                        "title": "Max competitors to crawl and score",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap on candidate URLs sent to the content crawler after deduplication and blocklist filtering. Higher-ranking SERP results are preferred.",
                        "default": 200
                    },
                    "openRouterModel": {
                        "title": "OpenRouter model",
                        "type": "string",
                        "description": "Model ID passed to the Apify OpenRouter Actor. See https://openrouter.ai/models for options.",
                        "default": "openai/gpt-4o-mini"
                    },
                    "filteringThreshold": {
                        "title": "Competitor score filtering threshold",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only companies scored at or above this value move on to the contact-scraping step. Companies with score `null` (scoring failed) are always dropped.",
                        "default": 75
                    },
                    "targetDepartment": {
                        "title": "Target department for lead enrichment",
                        "enum": [
                            "c_suite",
                            "product",
                            "engineering_technical",
                            "design",
                            "education",
                            "finance",
                            "human_resources",
                            "information_technology",
                            "legal",
                            "marketing",
                            "medical_health",
                            "operations",
                            "sales",
                            "consulting"
                        ],
                        "type": "string",
                        "description": "Department to enrich leads from at each qualifying company. Passed to vdrmota/contact-info-scraper as leadsEnrichmentDepartments.",
                        "default": "sales"
                    },
                    "leadsPerCompany": {
                        "title": "Leads per company",
                        "minimum": 0,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Maximum number of enriched leads to fetch from each qualifying company. Passed as maximumLeadsEnrichmentRecords to the contact scraper.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```