# SuperbCompanies Agency Directory Scraper (`automation-lab/superbcompanies-agency-directory-scraper`) Actor

Extract SuperbCompanies agency listings, websites, ratings, services, locations, public contacts, and profile details for B2B lead research.

- **URL**: https://apify.com/automation-lab/superbcompanies-agency-directory-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.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

## SuperbCompanies Agency Directory Scraper

Extract agency listings, profiles, ratings, services, locations, contact details, and company links from public SuperbCompanies directories.

Use this actor to turn SuperbCompanies category pages into clean agency lead, vendor research, and competitor intelligence datasets.

### What does SuperbCompanies Agency Directory Scraper do?

SuperbCompanies Agency Directory Scraper collects public agency records from SuperbCompanies category and organization profile pages.

It reads the structured data embedded in SuperbCompanies pages and saves one dataset row per agency.

The actor can start from category URLs such as software development companies, web development companies, IT consulting companies, or from individual organization profile URLs.

When profile enrichment is enabled, it also opens each public organization profile to collect deeper company data.

### Who is it for?

🧑‍💼 **B2B sales and RevOps teams** use it to build agency prospect lists for CRM import.

🤝 **Agency partnership teams** use it to discover potential implementation, white-label, or referral partners.

📊 **Vendor-shortlisting consultants** use it to compare agencies by services, location, hourly rate, size, and profile completeness.

🕵️ **Competitor researchers** use it to monitor how agencies are positioned across SuperbCompanies rankings.

🧰 **Data teams** use it to enrich internal supplier databases with repeatable public directory data.

### Why use this actor?

SuperbCompanies pages are useful for agency discovery, but manual copy-paste is slow and inconsistent.

This actor gives you structured output with stable field names.

It supports pagination, profile enrichment, deduplication across multiple inputs, and Apify dataset export formats.

You can run it on a small category sample or scale it to thousands of agency records.

### What data can you extract?

| Field | Description |
| --- | --- |
| `name` | Agency or vendor name |
| `profileUrl` | SuperbCompanies organization page |
| `websiteUrl` | Public company website when available |
| `sourceCategory` | Category page title |
| `rank` | Position on the scraped category page |
| `rating` | SuperbCompanies rating value when present |
| `reviewCount` | Number of public reviews when present |
| `location` | Human-readable primary locations |
| `locations` | Structured offices with city, state, country, address, phone |
| `hourlyRate` | Listed hourly rate range |
| `projectCost` | Listed minimum project cost range |
| `employees` | Company size range |
| `founded` | Founded year |
| `email` | Public business email when present on the profile |
| `phone` | Public phone from profile locations |
| `services` | Service categories and percentages |
| `industries` | Industry focus and percentages |
| `social` | Public social profile links |
| `featuredClients` | Public featured client names |
| `description` | Public company description or summary |
| `scrapedAt` | ISO timestamp for the scrape |

### How much does it cost to scrape SuperbCompanies agency listings?

This actor uses pay-per-event pricing.

There is a $0.005 start charge for each run and a tiered per-agency charge for every saved dataset item.

Current per-agency `result` event prices: FREE $0.00024974, BRONZE $0.00021716, SILVER $0.00016939, GOLD $0.0001303, PLATINUM $0.000086865, DIAMOND $0.000060805.

A realistic 110-agency cloud run passed the formula gate with 75.2% NET margin.

### Quick start

1. Open the actor on Apify.
2. Add one or more SuperbCompanies category URLs.
3. Set `maxItems` to the number of agencies you need.
4. Keep profile enrichment enabled if you want website, email, locations, services, social links, and richer descriptions.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, RSS, or HTML.

### Input configuration

```json
{
  "startUrls": [
    { "url": "https://superbcompanies.com/categories/software-development-companies/" }
  ],
  "maxItems": 100,
  "includeProfileDetails": true,
  "maxPagesPerStartUrl": 2
}
````

### Input fields

#### `startUrls`

Add SuperbCompanies category URLs or organization profile URLs.

Examples:

- `https://superbcompanies.com/categories/software-development-companies/`
- `https://superbcompanies.com/categories/web-development-companies/`
- `https://superbcompanies.com/organizations/devico-solutions/`

#### `maxItems`

The maximum number of agencies to save across all inputs.

Use a small value for tests and a larger value for production lead generation.

#### `includeProfileDetails`

When enabled, the actor opens each organization profile for richer fields.

Disable it for faster category-only sampling.

#### `maxPagesPerStartUrl`

Controls how many paginated category pages the actor may visit for each category URL.

SuperbCompanies category pages currently expose about 50 agencies per page.

### Output example

```json
{
  "name": "Devico Solutions",
  "profileUrl": "https://superbcompanies.com/organizations/devico-solutions/",
  "websiteUrl": "https://devico.io/",
  "sourceCategory": "Top Software Development Companies",
  "rank": 1,
  "location": "Lviv, Lvivska oblast, Ukraine | Warszawa, Masovian Voivodeship, Poland",
  "hourlyRate": "$25 - $49/hr",
  "projectCost": "$10000 - $24999",
  "employees": "50 - 199",
  "founded": "2011",
  "services": [{ "name": "Software Development", "percent": 60 }],
  "scrapedAt": "2026-07-03T00:00:00.000Z"
}
```

### Common workflows

#### Build agency lead lists

Scrape relevant SuperbCompanies categories and export the result to CSV.

Import the data into HubSpot, Salesforce, Pipedrive, Clay, Airtable, or Google Sheets.

#### Compare agency vendors

Use service mix, hourly rate, company size, locations, and descriptions to shortlist agencies.

#### Monitor competitor positioning

Run the same category on a schedule and compare ranks, descriptions, reviews, and profile fields over time.

#### Enrich an existing company database

Start from known SuperbCompanies profile URLs and enrich your internal records with public profile data.

### Tips for better results

Use category URLs from SuperbCompanies rather than generic home page URLs.

Keep `includeProfileDetails` enabled when you need contact or service details.

Increase `maxPagesPerStartUrl` when you need more than the first category page.

Use multiple related categories to capture agencies that appear in different service rankings.

Deduplicate downstream by `profileUrl` or `websiteUrl`.

### Integrations

Export directly to Apify datasets and connect the data to your stack.

Typical integrations include:

- CRM import into Salesforce, HubSpot, or Pipedrive.
- Spreadsheet analysis in Google Sheets or Excel.
- Data warehouse loads into BigQuery, Snowflake, or PostgreSQL.
- Lead enrichment workflows in Clay or Make.
- Scheduled monitoring via Apify tasks and webhooks.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/superbcompanies-agency-directory-scraper').call({
  startUrls: [{ url: 'https://superbcompanies.com/categories/software-development-companies/' }],
  maxItems: 100,
  includeProfileDetails: true,
});

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

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/superbcompanies-agency-directory-scraper').call(run_input={
    'startUrls': [{'url': 'https://superbcompanies.com/categories/software-development-companies/'}],
    'maxItems': 100,
    'includeProfileDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~superbcompanies-agency-directory-scraper/runs?token=<APIFY_TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{"url":"https://superbcompanies.com/categories/software-development-companies/"}],
    "maxItems": 100,
    "includeProfileDetails": true
  }'
```

### MCP integration

Use Apify MCP to call this actor from Claude Desktop, Claude Code, or other MCP clients.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/superbcompanies-agency-directory-scraper
```

Claude Code setup:

```bash
claude mcp add apify-superbcompanies https://mcp.apify.com/?tools=automation-lab/superbcompanies-agency-directory-scraper
```

Claude Desktop JSON config:

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

Example prompts:

- "Scrape 100 software development agencies from SuperbCompanies and summarize locations."
- "Find agencies with public websites and hourly rates under $50/hr."
- "Create a CSV-ready lead list from this SuperbCompanies category URL."

### Scheduling and monitoring

Create an Apify task with fixed category URLs and run it weekly or monthly.

Store each run's dataset or send results to your database through a webhook.

This is useful for rank monitoring, new agency discovery, and vendor database refreshes.

### Data freshness

The actor reads data that SuperbCompanies publicly serves at run time.

If SuperbCompanies updates rankings, descriptions, or profile data, new actor runs will reflect those changes.

Use `scrapedAt` to track when each row was collected.

### Limitations

The actor only collects public data available in the page payload.

It does not log in, bypass paywalls, submit contact forms, or access private user data.

Some profiles may not include email, phone, social links, or detailed service percentages.

Category coverage depends on SuperbCompanies pagination and page availability.

### Troubleshooting

If you get fewer rows than expected, increase `maxPagesPerStartUrl` and `maxItems`.

If a profile has missing contact fields, SuperbCompanies likely does not publish those fields for that agency.

If a category URL returns no data, verify that it is a live SuperbCompanies category page.

If runs are slow, disable `includeProfileDetails` for category-only sampling.

### Legality

This actor extracts publicly available directory information.

### Is it legal to scrape SuperbCompanies?

This actor extracts publicly available directory information.

You are responsible for using the data lawfully and respecting applicable privacy, database, copyright, and marketing rules.

Do not use scraped contact data for spam or unlawful outreach.

Consult your legal team if your use case has compliance requirements.

### Related scrapers

Related Automation Lab actors for B2B and directory research:

- https://apify.com/automation-lab/google-maps-business-scraper
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/yelp-business-scraper

Use this actor when SuperbCompanies is the source of truth for your workflow.

Use the related actors when you need local business data, website contacts, or broader lead enrichment.

### FAQ

#### Can I scrape multiple SuperbCompanies categories in one run?

Yes. Add multiple category URLs to `startUrls`. The actor deduplicates agencies by profile URL.

#### Can I scrape a single agency profile?

Yes. Add a URL such as `https://superbcompanies.com/organizations/devico-solutions/`.

#### Does it return emails?

It returns public business emails when SuperbCompanies includes them in the organization profile payload.

#### Does it use a browser?

No. The actor uses HTTP and Cheerio because SuperbCompanies serves the relevant structured data in the initial HTML.

#### Can I run it on a schedule?

Yes. Create an Apify task and schedule it to refresh agency datasets automatically.

### Support

If a run fails, check the actor log first.

Include the run ID, input, and the SuperbCompanies URL you tried when reporting issues.

For best support, provide a small reproducible input with `maxItems` set to 5.

# Actor input Schema

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

SuperbCompanies category/search URLs (for example /categories/software-development-companies/) or individual /organizations/... profile URLs.

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

Maximum number of agency records to save across all start URLs.

## `includeProfileDetails` (type: `boolean`):

Fetch each agency profile to enrich listings with website, email, locations, phone, social links, services, industries, and clients where public.

## `maxPagesPerStartUrl` (type: `integer`):

Safety cap for category pagination. SuperbCompanies category pages currently contain about 50 agencies per page.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://superbcompanies.com/categories/software-development-companies/"
    }
  ],
  "maxItems": 20,
  "includeProfileDetails": true,
  "maxPagesPerStartUrl": 1
}
```

# Actor output Schema

## `datasetUrl` (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://superbcompanies.com/categories/software-development-companies/"
        }
    ],
    "maxItems": 20,
    "includeProfileDetails": true,
    "maxPagesPerStartUrl": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/superbcompanies-agency-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://superbcompanies.com/categories/software-development-companies/" }],
    "maxItems": 20,
    "includeProfileDetails": True,
    "maxPagesPerStartUrl": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/superbcompanies-agency-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://superbcompanies.com/categories/software-development-companies/"
    }
  ],
  "maxItems": 20,
  "includeProfileDetails": true,
  "maxPagesPerStartUrl": 1
}' |
apify call automation-lab/superbcompanies-agency-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SuperbCompanies Agency Directory Scraper",
        "description": "Extract SuperbCompanies agency listings, websites, ratings, services, locations, public contacts, and profile details for B2B lead research.",
        "version": "0.1",
        "x-build-id": "21YGOhZTKxw9uyfI6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~superbcompanies-agency-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-superbcompanies-agency-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~superbcompanies-agency-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-superbcompanies-agency-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~superbcompanies-agency-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-superbcompanies-agency-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Category or profile URLs",
                        "type": "array",
                        "description": "SuperbCompanies category/search URLs (for example /categories/software-development-companies/) or individual /organizations/... profile URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum agencies",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of agency records to save across all start URLs.",
                        "default": 20
                    },
                    "includeProfileDetails": {
                        "title": "Open agency profile pages",
                        "type": "boolean",
                        "description": "Fetch each agency profile to enrich listings with website, email, locations, phone, social links, services, industries, and clients where public.",
                        "default": true
                    },
                    "maxPagesPerStartUrl": {
                        "title": "Maximum category pages per URL",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety cap for category pagination. SuperbCompanies category pages currently contain about 50 agencies per page.",
                        "default": 2
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
