# Axial M\&A Advisor Directory Scraper (`automation-lab/axial-ma-advisor-directory-scraper`) Actor

Extract firm records, profile links, descriptions, deal counts, and public contact metadata from Axial's M\&A advisor directory.

- **URL**: https://apify.com/automation-lab/axial-ma-advisor-directory-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Axial M&A Advisor Directory Scraper

Extract firm records from Axial's public company directory: investment banks, M&A advisory firms, business brokers, private equity funds, family offices, holding companies, and independent sponsors. The actor crawls category pages, follows pagination, optionally enriches records from public firm profile pages, and saves clean rows for CRM, market mapping, outreach, and research workflows.

### What does Axial M&A Advisor Directory Scraper do?

Axial M&A Advisor Directory Scraper turns public Axial directory pages into a structured dataset.

It collects firm names, Axial profile URLs, firm types, descriptions, deal-count signals, logo URLs, recent transaction summaries, profile metadata, and public location hints when available.

Use it when you need a repeatable extractor instead of manually copying firms from pages such as:

- `https://www.axial.net/forum/companies/investment-banks/`
- `https://www.axial.net/forum/companies/m-a-advisory-firms/`
- `https://www.axial.net/forum/companies/business-brokers/`
- `https://www.axial.net/forum/companies/private-equity-funds/`
- `https://www.axial.net/forum/companies/family-offices/`

### Who is it for?

This actor is built for buyers who work with lower-middle-market M&A and private-company deal networks.

- 🧭 **M&A platform operators** building reference lists of advisors and intermediaries.
- 💼 **Private equity and independent sponsor researchers** mapping advisor coverage by category.
- 📇 **Broker CRM teams** refreshing firm names, profile links, and short descriptions.
- 📣 **B2B outreach teams** creating seed lists for enrichment and compliant outbound workflows.
- 📊 **Market intelligence analysts** tracking which firms appear in public Axial categories.

### Why use this actor?

Axial pages are useful but not convenient to export. This actor gives you:

- structured dataset rows instead of copied page snippets;
- predictable pagination limits;
- profile URL deduplication across sources;
- optional profile-page enrichment;
- conservative HTTP crawling without a browser;
- pay-per-result pricing that scales with the number of saved firms.

### Data extracted

Typical output fields include:

| Field | Description |
| --- | --- |
| `firmName` | Firm or company name shown by Axial |
| `profileUrl` | Public Axial profile URL |
| `category` | Directory category inferred from the source page |
| `sourceUrl` | Category page where the record was found |
| `firmType` | Firm type, such as Investment Bank or Business Broker |
| `location` | Location parsed from public profile metadata when available |
| `firmDescription` | Directory card description |
| `website` | External website link when publicly exposed on the profile page |
| `logoUrl` | Logo image URL from the directory card |
| `closedDealsViaAxial` | Closed-deal count shown on Axial, when present |
| `totalClosedDeals` | Total closed-deal count shown on Axial, when present |
| `recentTransactions` | Recent public transaction snippets from the card |
| `metaDescription` | Public SEO/profile description from the firm profile |
| `scrapedAt` | ISO timestamp for the extraction run |

### How much does it cost to scrape Axial advisor directory records?

The actor uses pay-per-event pricing.

- Start event: a small one-time run charge.
- Item event: charged per saved firm record.

Final tiered prices are set after cloud cost validation. The default input is intentionally small enough for an inexpensive first run.

### Input options

You can use full directory URLs or category slugs.

#### Axial directory URLs

Provide one or more public Axial directory URLs in `startUrls`.

Example:

```json
{
  "startUrls": [
    { "url": "https://www.axial.net/forum/companies/investment-banks/" },
    { "url": "https://www.axial.net/forum/companies/business-brokers/" }
  ],
  "maxItems": 100,
  "maxPagesPerCategory": 5,
  "includeProfiles": true
}
````

#### Category slugs

Use `categories` for Axial category slugs.

```json
{
  "categories": ["m-a-advisory-firms", "business-brokers"],
  "maxItems": 250,
  "maxPagesPerCategory": 10,
  "includeProfiles": true
}
```

### Default categories

If you do not provide `startUrls` or `categories`, the actor starts with:

- investment banks;
- M\&A advisory firms;
- business brokers.

These defaults match common lead-research workflows for lower-middle-market M\&A.

### Output example

```json
{
  "firmName": "FOCUS Investment Banking",
  "profileUrl": "https://www.axial.net/company/focus-investment-banking1",
  "category": "Investment Banks",
  "firmType": "Investment Bank",
  "location": "Vienna, Virginia",
  "closedDealsViaAxial": 4,
  "totalClosedDeals": 187,
  "recentTransactions": ["Advisor Sep 2025 Anonymous was acquired by Confidential Company"],
  "scrapedAt": "2026-06-29T03:36:14.202Z"
}
```

### How to run it

1. Open the actor on Apify.
2. Keep the default directory URLs or add your own Axial category pages.
3. Set `maxItems` to the number of firm records you need.
4. Keep `includeProfiles` enabled if you want profile metadata and location hints.
5. Run the actor and export the dataset as JSON, CSV, Excel, or through the API.

### Tips for best results

- Use a low `maxItems` for the first run.
- Increase `maxPagesPerCategory` when you want deeper pagination.
- Use category slugs when you already know the Axial directory segment.
- Disable `includeProfiles` for faster category-only extraction.
- Deduplicate downstream by `profileUrl` if you merge multiple runs.

### Integrations

You can connect the dataset to common sales and research workflows:

- CRM imports for advisor and broker account creation;
- spreadsheet-based market maps;
- enrichment tools that append websites, emails, and LinkedIn pages;
- data warehouses for recurring M\&A ecosystem monitoring;
- lead-scoring systems that combine category and deal-count signals.

### API usage: Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/axial-ma-advisor-directory-scraper').call({
  categories: ['investment-banks'],
  maxItems: 100,
  includeProfiles: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 3));
```

### API usage: Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/axial-ma-advisor-directory-scraper').call(run_input={
    'categories': ['business-brokers'],
    'maxItems': 100,
    'includeProfiles': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

### API usage: cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~axial-ma-advisor-directory-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"categories":["m-a-advisory-firms"],"maxItems":100,"includeProfiles":true}'
```

### MCP: use with Claude and other clients

Use the Apify MCP server with this actor enabled:

```bash
npx -y @apify/actors-mcp-server --actors automation-lab/axial-ma-advisor-directory-scraper
```

MCP URL format:

```text
https://mcp.apify.com/?tools=automation-lab/axial-ma-advisor-directory-scraper
```

JSON configuration example:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/axial-ma-advisor-directory-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 100 Axial investment banks and summarize the most common locations."
- "Create a CSV of Axial business brokers with profile URLs and deal counts."
- "Find M\&A advisory firms from Axial and prepare a CRM import table."

### Profile enrichment

When `includeProfiles` is enabled, the actor opens each public Axial profile URL and tries to collect public metadata such as SEO descriptions and location hints.

Profile enrichment is slower because it adds one HTTP request per firm. Disable it for quick directory-card exports.

### Pagination behavior

The actor follows Axial pagination links inside each category until it reaches:

- `maxItems`,
- `maxPagesPerCategory`, or
- no new page links.

This keeps runs bounded and avoids unexpectedly large crawls.

### Limits and caveats

- The actor extracts only public information visible from Axial pages.
- Some profiles do not expose websites or locations publicly.
- Axial page structure can change; report broken fields if output suddenly becomes sparse.
- Transaction snippets may include anonymized or confidential parties exactly as Axial displays them.
- The actor does not log in to Axial or access private network data.

### Legality

Axial M\&A Advisor Directory Scraper is designed for public business-directory research. It does not bypass login walls, scrape private Axial network data, or access non-public account resources.

### Legal and ethical use

Use this actor only for lawful purposes and respect applicable privacy, marketing, and platform terms. Public business directory data may still require compliant handling when used for outreach, enrichment, or CRM workflows.

### Troubleshooting

#### The run returned fewer records than expected

Increase `maxPagesPerCategory`, check that the category URL is public, and confirm `maxItems` is high enough.

#### Website is blank for many records

Many Axial public profile pages do not expose external websites. Use `profileUrl` as the stable source link and enrich externally if needed.

#### The actor is slower with profiles enabled

That is expected. Profile enrichment adds one request per firm. Set `includeProfiles` to `false` for faster category-listing exports.

### Related scrapers

Other Automation Lab actors can complement this workflow:

- LinkedIn and company-profile enrichment actors for appending professional signals.
- Website/contact discovery actors for finding public company domains and contact pages.
- Directory and lead-list scrapers for adjacent B2B market mapping.

### FAQ

#### Can I scrape only one category?

Yes. Provide one `startUrls` entry or one category slug.

#### Can I scrape city-filtered Axial pages?

Yes. Put the city-filtered Axial directory URL in `startUrls`.

#### Does this actor need proxies?

The implementation is HTTP-first and normally does not require a browser. Conservative usage is recommended.

#### Does it access private Axial account data?

No. It only extracts public directory/profile pages.

#### What is the best unique key?

Use `profileUrl` as the stable deduplication key.

### Support

If a category stops working, include the run ID, input JSON, and a sample URL. That makes it easier to distinguish target HTML changes from input or limit settings.

# Actor input Schema

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

Optional Axial directory category URLs to crawl. Leave empty to use the default investment bank, M\&A advisory firm, and business broker categories.

## `categories` (type: `array`):

Optional Axial category slugs such as investment-banks, m-a-advisory-firms, business-brokers, private-equity-funds, family-offices, or independent-sponsors.

## `maxItems` (type: `integer`):

Maximum number of firm records to save across all selected directories.

## `maxPagesPerCategory` (type: `integer`):

Safety limit for paginated category pages. Each Axial page usually contains about 20 firms.

## `includeProfiles` (type: `boolean`):

Open each firm profile URL to enrich records with meta descriptions, locations, and external website links when public.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.axial.net/forum/companies/investment-banks/"
    },
    {
      "url": "https://www.axial.net/forum/companies/m-a-advisory-firms/"
    },
    {
      "url": "https://www.axial.net/forum/companies/business-brokers/"
    }
  ],
  "categories": [
    "investment-banks"
  ],
  "maxItems": 20,
  "maxPagesPerCategory": 5,
  "includeProfiles": true
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.axial.net/forum/companies/investment-banks/"
        },
        {
            "url": "https://www.axial.net/forum/companies/m-a-advisory-firms/"
        },
        {
            "url": "https://www.axial.net/forum/companies/business-brokers/"
        }
    ],
    "categories": [
        "investment-banks"
    ],
    "maxItems": 20,
    "maxPagesPerCategory": 5,
    "includeProfiles": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/axial-ma-advisor-directory-scraper").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 = {
    "startUrls": [
        { "url": "https://www.axial.net/forum/companies/investment-banks/" },
        { "url": "https://www.axial.net/forum/companies/m-a-advisory-firms/" },
        { "url": "https://www.axial.net/forum/companies/business-brokers/" },
    ],
    "categories": ["investment-banks"],
    "maxItems": 20,
    "maxPagesPerCategory": 5,
    "includeProfiles": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/axial-ma-advisor-directory-scraper").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 '{
  "startUrls": [
    {
      "url": "https://www.axial.net/forum/companies/investment-banks/"
    },
    {
      "url": "https://www.axial.net/forum/companies/m-a-advisory-firms/"
    },
    {
      "url": "https://www.axial.net/forum/companies/business-brokers/"
    }
  ],
  "categories": [
    "investment-banks"
  ],
  "maxItems": 20,
  "maxPagesPerCategory": 5,
  "includeProfiles": true
}' |
apify call automation-lab/axial-ma-advisor-directory-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/axial-ma-advisor-directory-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Axial M&A Advisor Directory Scraper",
        "description": "Extract firm records, profile links, descriptions, deal counts, and public contact metadata from Axial's M&A advisor directory.",
        "version": "0.1",
        "x-build-id": "CYqqdrmhTFXmI5QYx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~axial-ma-advisor-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-axial-ma-advisor-directory-scraper",
                "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/automation-lab~axial-ma-advisor-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-axial-ma-advisor-directory-scraper",
                "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/automation-lab~axial-ma-advisor-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-axial-ma-advisor-directory-scraper",
                "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": {
                    "startUrls": {
                        "title": "Axial directory URLs",
                        "type": "array",
                        "description": "Optional Axial directory category URLs to crawl. Leave empty to use the default investment bank, M&A advisory firm, and business broker categories.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "categories": {
                        "title": "Category slugs",
                        "type": "array",
                        "description": "Optional Axial category slugs such as investment-banks, m-a-advisory-firms, business-brokers, private-equity-funds, family-offices, or independent-sponsors.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum firms",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of firm records to save across all selected directories.",
                        "default": 20
                    },
                    "maxPagesPerCategory": {
                        "title": "Maximum pages per category",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Safety limit for paginated category pages. Each Axial page usually contains about 20 firms.",
                        "default": 10
                    },
                    "includeProfiles": {
                        "title": "Visit firm profile pages",
                        "type": "boolean",
                        "description": "Open each firm profile URL to enrich records with meta descriptions, locations, and external website links when public.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
