# Vault Company Profiles Scraper (`crawlerbros/vault-scraper`) Actor

Scrape Vault.com company profiles: salary data, rankings, benefits, departments, offices, and editorial company culture info for law, consulting, banking, and other professional-services employers. No login required.

- **URL**: https://apify.com/crawlerbros/vault-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Jobs, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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/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

## Vault Company Profiles Scraper

Scrape company salary, rankings, benefits, departments, offices, and culture data from [Vault.com](https://vault.com) company profiles — no login, no cookies, no API key required. Vault covers thousands of employers across law, consulting, banking, accounting, technology, and other professional-services industries.

### What this actor does

- **Company profiles** — first-year/base salary figures, salary-vs-industry positioning, employee count, company type, featured rankings (e.g. "Vault Law 100", "Best Consulting Firms for Compensation"), major departments/practice areas, office locations, career site & newsroom links, top executives, notable cases/awards, "About the Company", and "Why Work Here" editorial content.
- **Benefits & perks** — every benefit Vault lists for a company, grouped by category (Family & Wellness, Health, Financial, Vacation & Time Off, and more).
- **Company directory** — browse or fully paginate Vault's ~1,288-company directory (name, logo, profile URL), filterable by industry, US state/location, and company size, and sortable by name or size.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `profile` | `profile` / `benefits` / `companies` |
| `companyPaths` | array | `["management-strategy/bain-company"]` | Vault `industry/slug` paths or full profile URLs (mode=profile/benefits) |
| `maxItems` | integer | `50` | Hard cap on total emitted records. For `mode=companies`, set this near ~1300 to pull Vault's full live directory |
| `industry` | string (select) | none | mode=companies only — filter to one Vault industry category (e.g. `Consulting`, `Law`) |
| `location` | array (select) | none | mode=companies only — filter to one or more US states (or `International`) |
| `companySize` | array (select) | none | mode=companies only — filter to one or more employee-count buckets |
| `sortBy` | string (select) | `az` | mode=companies only — `az` / `za` / `ls` (largest company size first) / `sl` (smallest first) |
| `proxyConfiguration` | object | Apify proxy | Leave on default — auto-escalates on a block |

#### Finding a company path

A Vault company profile URL looks like `https://vault.com/company-profiles/law/kirkland-ellis` — the path is everything after `/company-profiles/` (`law/kirkland-ellis`). If you don't know a company's industry segment, run `mode=companies` first to browse the directory and copy the `companyPath` field from any result.

#### Example: full company profile

```json
{
  "mode": "profile",
  "companyPaths": ["law/kirkland-ellis", "management-strategy/accenture"]
}
````

#### Example: benefits & perks

```json
{
  "mode": "benefits",
  "companyPaths": ["management-strategy/bain-company"]
}
```

#### Example: browse the directory

```json
{
  "mode": "companies",
  "maxItems": 18
}
```

#### Example: pull the full directory, filtered and sorted

```json
{
  "mode": "companies",
  "maxItems": 1300,
  "industry": "Consulting",
  "location": ["CA", "NY"],
  "sortBy": "az"
}
```

### Output

Output shape depends on `mode`. All records include `recordType` and `scrapedAt`. Empty/unavailable fields are always omitted — Vault doesn't publish every field for every company (e.g. law firms show `partnerCount`/`firstYearSalary`; consulting firms show `companyType`/`affiliatedCompanies` instead).

**profile** (`companyProfile`):

- `companyName`, `companyPath`, `companyUrl`, `industry`, `logoUrl`
- `firstYearSalary`, `salaryRangeVsIndustry` (positioning vs. industry peers)
- `employeeCount`, `companyType`, `partnerCount`, `topExecutive`, `otherExecutives`, `affiliatedCompanies`
- `rankings[]`, `majorDepartments[]`, `majorLocations[]`
- `careerSiteUrl`, `newsSiteUrl`, `notableCases`, `notableAwards`
- `aboutCompany`, `whyWorkHere`
- `otherStats` — any additional industry-specific stats Vault publishes for that company

**benefits** (`benefit`):

- `companyName`, `companyPath`, `benefitCategory`, `benefit`

**companies** (`companyListing`):

- `companyName`, `companyPath`, `companyUrl`, `logoUrl`
- `industry` — only present when the `industry` input filter was applied (Vault's directory API never exposes a per-company sector/industry value on unfiltered results, so this reflects the filter you applied rather than a per-record field)

### Use cases

- **Compensation benchmarking** — compare first-year/base salary figures and industry salary positioning across law firms, consulting firms, and banks.
- **Employer branding research** — pull rankings and benefits data for competitor analysis in professional services.
- **Recruiting & talent intelligence** — surface department structure, office locations, and "Why Work Here" messaging for target employers.
- **Career research** — check a firm's benefits package and Vault ranking before applying.
- **Market mapping** — build a competitor set by industry using the company directory.

### FAQs

**Do I need to provide cookies or an API key?**  No — all data comes from public, unauthenticated Vault.com pages.

**What if a company path doesn't exist on Vault?**  The actor logs a warning and skips it; it never crashes the run. Run `mode=companies` to confirm the exact `industry/slug` path first.

**Why do some companies have `partnerCount`/`firstYearAssociateCount` and others don't?**  Vault tailors its stats to each industry — law firms report partner and associate headcounts; consulting and corporate profiles report company type and affiliated regional entities instead. Fields with no underlying data are omitted rather than sent as blank/null.

**Does `mode=companies` support search or pagination?**  Yes — it paginates through Vault's full live directory (~1,288 companies as of testing) and supports `industry`, `location`, and `companySize` filters plus `sortBy`. Set `maxItems` near the total to pull everything; a plain "public/private" company-type filter exists in Vault's own filter metadata but has no working request parameter, so it is intentionally not exposed here.

**How current is the data?**  Vault profile pages reflect the live company profile at scrape time; Vault itself updates rankings annually and salary/benefits data as firms report changes.

**Can I run multiple companies in one call?**  Yes — pass multiple paths in `companyPaths`; the actor processes them sequentially and applies `maxItems` across the combined output.

# Actor input Schema

## `mode` (type: `string`):

What to scrape.

## `companyPaths` (type: `array`):

Vault `industry/company-slug` paths (e.g. `management-strategy/bain-company`, `law/kirkland-ellis`) or full profile URLs (e.g. `https://vault.com/company-profiles/law/kirkland-ellis`). Not sure of the industry segment? Run `mode=companies` first to find valid paths.

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

Hard cap on the total number of records emitted. For mode=companies, Vault's live directory holds ~1,288 companies (~13 pages of 100) — set this near that ceiling to pull the full directory.

## `industry` (type: `string`):

Only return companies in this Vault industry category. Leave blank for all industries.

## `location` (type: `array`):

Only return companies headquartered/located in these states (or International). Leave empty for all locations.

## `companySize` (type: `array`):

Only return companies in these employee-count buckets. Leave empty for all sizes.

## `sortBy` (type: `string`):

Sort order for the company directory.

## `proxyConfiguration` (type: `object`):

vault.com has shown no bot-management challenges in testing. The actor connects directly and automatically escalates to Apify's free datacenter proxy on a block, purely as a safety net. Leave this on the default.

## Actor input object example

```json
{
  "mode": "profile",
  "companyPaths": [
    "management-strategy/bain-company"
  ],
  "maxItems": 50,
  "industry": "",
  "location": [],
  "companySize": [],
  "sortBy": "az",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped Vault.com records.

# 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 = {
    "mode": "profile",
    "companyPaths": [
        "management-strategy/bain-company"
    ],
    "maxItems": 50,
    "industry": "",
    "location": [],
    "companySize": [],
    "sortBy": "az",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/vault-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 = {
    "mode": "profile",
    "companyPaths": ["management-strategy/bain-company"],
    "maxItems": 50,
    "industry": "",
    "location": [],
    "companySize": [],
    "sortBy": "az",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/vault-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 '{
  "mode": "profile",
  "companyPaths": [
    "management-strategy/bain-company"
  ],
  "maxItems": 50,
  "industry": "",
  "location": [],
  "companySize": [],
  "sortBy": "az",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/vault-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vault Company Profiles Scraper",
        "description": "Scrape Vault.com company profiles: salary data, rankings, benefits, departments, offices, and editorial company culture info for law, consulting, banking, and other professional-services employers. No login required.",
        "version": "1.0",
        "x-build-id": "J3nlIzIGq6ZxXii6b"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~vault-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-vault-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/crawlerbros~vault-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-vault-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/crawlerbros~vault-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-vault-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "profile",
                            "benefits",
                            "companies"
                        ],
                        "type": "string",
                        "description": "What to scrape.",
                        "default": "profile"
                    },
                    "companyPaths": {
                        "title": "Company paths or URLs (mode=profile/benefits)",
                        "type": "array",
                        "description": "Vault `industry/company-slug` paths (e.g. `management-strategy/bain-company`, `law/kirkland-ellis`) or full profile URLs (e.g. `https://vault.com/company-profiles/law/kirkland-ellis`). Not sure of the industry segment? Run `mode=companies` first to find valid paths.",
                        "default": [
                            "management-strategy/bain-company"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on the total number of records emitted. For mode=companies, Vault's live directory holds ~1,288 companies (~13 pages of 100) — set this near that ceiling to pull the full directory.",
                        "default": 50
                    },
                    "industry": {
                        "title": "Industry filter (mode=companies)",
                        "enum": [
                            "",
                            "Accounting",
                            "Biology and Life Sciences",
                            "Cannabis",
                            "Commercial Banking",
                            "Consulting",
                            "Consumer Products and Services",
                            "Economics",
                            "Energy",
                            "Engineering",
                            "Fashion and Apparel",
                            "Financial Consulting",
                            "Financial Technology",
                            "Food and Beverages",
                            "Government",
                            "Hardware",
                            "Health Care and Pharmaceuticals Consulting",
                            "Health Care Management",
                            "Information Technology Consulting",
                            "Insurance",
                            "Internet Services",
                            "Investment Banking",
                            "Investment Management",
                            "Law",
                            "Management and Strategy Consulting",
                            "Marketing",
                            "Market Research",
                            "Media and Entertainment",
                            "Nonprofit Sector",
                            "Payment Services",
                            "Pharmaceuticals and Biotechnology",
                            "Retail",
                            "Sales and Trading",
                            "Social Media",
                            "Software",
                            "Staffing and Human Resources Consulting",
                            "Tech",
                            "Telecommunications",
                            "Toys and Games",
                            "Venture Capital",
                            "Wealth Management"
                        ],
                        "type": "string",
                        "description": "Only return companies in this Vault industry category. Leave blank for all industries.",
                        "default": ""
                    },
                    "location": {
                        "title": "US state / location filter (mode=companies)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only return companies headquartered/located in these states (or International). Leave empty for all locations.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "AL",
                                "AK",
                                "AZ",
                                "AR",
                                "CA",
                                "CO",
                                "CT",
                                "DE",
                                "DC",
                                "FL",
                                "GA",
                                "HI",
                                "ID",
                                "IL",
                                "IN",
                                "IA",
                                "KS",
                                "KY",
                                "LA",
                                "ME",
                                "MD",
                                "MA",
                                "MI",
                                "MN",
                                "MS",
                                "MO",
                                "MT",
                                "NE",
                                "NV",
                                "NH",
                                "NJ",
                                "NM",
                                "NY",
                                "NC",
                                "ND",
                                "OH",
                                "OK",
                                "OR",
                                "PA",
                                "RI",
                                "SC",
                                "SD",
                                "TN",
                                "TX",
                                "UT",
                                "VT",
                                "VA",
                                "WA",
                                "WV",
                                "WI",
                                "WY",
                                "International"
                            ],
                            "enumTitles": [
                                "Alabama",
                                "Alaska",
                                "Arizona",
                                "Arkansas",
                                "California",
                                "Colorado",
                                "Connecticut",
                                "Delaware",
                                "District of Columbia",
                                "Florida",
                                "Georgia",
                                "Hawaii",
                                "Idaho",
                                "Illinois",
                                "Indiana",
                                "Iowa",
                                "Kansas",
                                "Kentucky",
                                "Louisiana",
                                "Maine",
                                "Maryland",
                                "Massachusetts",
                                "Michigan",
                                "Minnesota",
                                "Mississippi",
                                "Missouri",
                                "Montana",
                                "Nebraska",
                                "Nevada",
                                "New Hampshire",
                                "New Jersey",
                                "New Mexico",
                                "New York",
                                "North Carolina",
                                "North Dakota",
                                "Ohio",
                                "Oklahoma",
                                "Oregon",
                                "Pennsylvania",
                                "Rhode Island",
                                "South Carolina",
                                "South Dakota",
                                "Tennessee",
                                "Texas",
                                "Utah",
                                "Vermont",
                                "Virginia",
                                "Washington",
                                "West Virginia",
                                "Wisconsin",
                                "Wyoming",
                                "International"
                            ]
                        },
                        "default": []
                    },
                    "companySize": {
                        "title": "Company size filter (mode=companies)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only return companies in these employee-count buckets. Leave empty for all sizes.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5",
                                "6"
                            ],
                            "enumTitles": [
                                "Under 100 Employees",
                                "100-500 Employees",
                                "501-1,000 Employees",
                                "1,001-5,000 Employees",
                                "5,001-10,000 Employees",
                                "10,001+ Employees"
                            ]
                        },
                        "default": []
                    },
                    "sortBy": {
                        "title": "Sort order (mode=companies)",
                        "enum": [
                            "az",
                            "za",
                            "ls",
                            "sl"
                        ],
                        "type": "string",
                        "description": "Sort order for the company directory.",
                        "default": "az"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "vault.com has shown no bot-management challenges in testing. The actor connects directly and automatically escalates to Apify's free datacenter proxy on a block, purely as a safety net. Leave this on the default.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
