# Built In Salaries Scraper (`automation-lab/builtin-salaries-scraper`) Actor

Scrape Built In salary benchmarks, compensation ranges, and recent salary reports by role and location.

- **URL**: https://apify.com/automation-lab/builtin-salaries-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **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

## Built In Salaries Scraper

Scrape public Built In salary benchmarks by role and location, including average base salary, additional cash compensation, total compensation, ranges, and recent anonymous salary reports.

Built In Salaries Scraper turns salary pages such as `https://builtin.com/salaries/us/software-engineer` into structured dataset rows that compensation, recruiting, and market-intelligence teams can analyze immediately.

### What does Built In Salaries Scraper do?

Built In Salaries Scraper extracts public compensation data from Built In salary benchmark pages.

It can collect:

- 💵 Average base salary
- 💰 Average additional cash compensation
- 📊 Average total compensation
- 📉 Median, minimum, and maximum salary values when available
- 🧾 Recent anonymous salary report rows
- 🧑‍💼 Reported job title, experience, gender, company size, and location
- 🔗 Related salary table rows when requested
- 🕒 Source URL and scrape timestamp for auditability

The actor is HTTP-first and designed for public pages that are visible without logging in.

### Who is it for?

This actor is useful for teams that need repeatable salary benchmark exports.

Typical users include:

- 🧑‍💼 Recruiters comparing compensation for open roles
- 📈 People operations teams preparing salary bands
- 🧮 Compensation analysts tracking market movement
- 🏢 Startup operators benchmarking offers against tech-market data
- 🔎 Job-market analysts combining salary and hiring signals
- 🧑‍💻 Developers building salary intelligence dashboards

### Why use this actor?

Built In pages are useful in a browser, but manual copy-paste does not scale.

This actor gives you:

- Structured rows instead of page text
- Repeatable runs for the same role list
- Dataset exports in JSON, CSV, Excel, XML, and RSS via Apify
- API access for scheduled compensation monitoring
- A low-memory HTTP implementation suitable for economical recurring jobs

### How much does it cost to scrape Built In salary data?

This actor uses pay-per-event pricing.

- A small start event is charged once per run.
- A result event is charged for each salary benchmark, recent salary report, or related salary row saved.

Current platform pricing is configured as a small `$0.005` start event plus tiered result pricing. Result events are charged per saved salary benchmark, recent salary report, or related salary row.

| Tier | Price per result | Approx. price per 1,000 results |
| --- | ---: | ---: |
| FREE | `$0.00005` | `$0.050` |
| BRONZE | `$0.000043478` | `$0.043` |
| SILVER | `$0.000033913` | `$0.034` |
| GOLD | `$0.000026087` | `$0.026` |
| PLATINUM | `$0.000017391` | `$0.017` |
| DIAMOND | `$0.000012174` | `$0.012` |

To control costs:

- Keep `maxItems` low for your first run.
- Use direct URLs when you know the exact pages.
- Disable related salary rows unless you need discovery data.
- Limit recent report rows with `maxReportsPerPage`.

### Input options

You can provide direct salary URLs, role names, or both.

#### Built In salary URLs

Use `startUrls` for exact pages:

```json
[
  { "url": "https://builtin.com/salaries/us/software-engineer" }
]
````

Direct URLs are best for city/category pages because Built In URL structures can vary by role family.

#### Role names or slugs

Use `roles` for national Built In salary pages:

```json
["Software Engineer", "Data Engineer"]
```

The actor converts these to `/salaries/us/<role-slug>` URLs.

#### Locations

Use `locations` to request national or discovered city pages.

Examples:

- `US`
- `Austin`
- `Seattle`
- `New York`

For city locations, the actor first fetches the role page and follows matching salary links found in the public HTML.

### Example input

```json
{
  "roles": ["Software Engineer"],
  "locations": ["US"],
  "maxItems": 25,
  "maxReportsPerPage": 20,
  "includeBenchmark": true,
  "includeRecentReports": true,
  "includeRelatedSalaries": false
}
```

### Output data

Each dataset row contains salary context plus fields for the selected record type.

| Field | Description |
| --- | --- |
| `recordType` | `benchmark`, `salary_report`, or `related_salary` |
| `sourceUrl` | Built In source page |
| `role` | Role extracted from the page title |
| `location` | Location extracted from the page title |
| `averageBaseSalary` | Average base salary in USD |
| `additionalCashCompensation` | Average additional cash compensation in USD |
| `averageTotalCompensation` | Average total compensation in USD |
| `medianSalary` | Median salary when available |
| `minSalary` | Minimum salary when available |
| `maxSalary` | Maximum salary when available |
| `reportedTitle` | Recent salary report job title |
| `reportedSalary` | Recent salary report yearly salary |
| `reportedAdditionalCash` | Recent report additional cash compensation |
| `reportedExperience` | Experience bucket from the report row |
| `reportedGender` | Gender value shown in the report row |
| `reportedCompanySize` | Company-size bucket from the report row |
| `reportedLocation` | Location shown in the report row |
| `relatedTitle` | Related role or city salary table title |
| `relatedAverageSalary` | Related salary average |
| `relatedUrl` | Related Built In salary URL |
| `scrapedAt` | ISO timestamp when the row was extracted |

### Record types

The actor uses one dataset with a `recordType` field.

#### `benchmark`

One row per salary page with summary compensation fields.

#### `salary_report`

One row per recent anonymous salary report, with benchmark fields repeated for context.

#### `related_salary`

One row per related salary table entry when `includeRelatedSalaries` is enabled.

### Tips for best results

- Start with one role and `maxItems` around 25.
- Use direct Built In salary URLs for niche city pages.
- Turn on related salaries when you want discovery rows.
- Use `maxReportsPerPage` to prevent one page from consuming the full item limit.
- Schedule repeat runs if you need compensation trend snapshots.

### Integrations

You can connect the dataset to:

- Google Sheets for compensation review workflows
- BI tools for market dashboards
- Applicant tracking systems for offer calibration
- Data warehouses for historical salary trend analysis
- Slack alerts for scheduled benchmark monitoring

A common workflow is:

1. Run the actor weekly for priority roles.
2. Export CSV or push dataset rows via API.
3. Compare current averages with internal salary bands.
4. Flag roles where market compensation changed materially.

### 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/builtin-salaries-scraper').call({
  roles: ['Software Engineer'],
  locations: ['US'],
  maxItems: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/builtin-salaries-scraper').call(run_input={
    'roles': ['Software Engineer'],
    'locations': ['US'],
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~builtin-salaries-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"roles":["Software Engineer"],"locations":["US"],"maxItems":25}'
```

### MCP usage

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

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/builtin-salaries-scraper
```

Claude Code quick add command:

```bash
claude mcp add apify-builtin-salaries https://mcp.apify.com/?tools=automation-lab/builtin-salaries-scraper
```

Claude Desktop JSON configuration:

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

Example prompts:

- "Scrape Built In salary reports for Software Engineer in the US."
- "Get Built In salary benchmarks for Data Engineer and summarize total compensation."
- "Run the Built In Salaries Scraper and export salary report rows as a table."

### Scheduling

Use Apify schedules for recurring salary monitoring.

Recommended cadence:

- Weekly for active recruiting roles
- Monthly for compensation-band review
- Quarterly for broad market benchmarking

Keep input lists small at first, then scale after you confirm the dataset shape matches your workflow.

### Legality

This actor extracts publicly available salary benchmark pages.

You are responsible for using the data in accordance with applicable laws, Built In terms, and privacy requirements. Do not use scraped data for prohibited discrimination, unlawful employment decisions, or any purpose that violates local regulations.

### Troubleshooting

#### Why did I get fewer rows than `maxItems`?

`maxItems` is a cap, not a guarantee. A page may show fewer recent reports than requested, or related rows may be disabled.

#### Why is a city page missing?

City URL structures can vary. Provide the direct Built In salary URL when you need a specific city/category page.

#### Why are some fields empty?

Built In does not show every metric on every page. The actor preserves missing values as null instead of guessing.

### FAQ

#### Can I scrape multiple roles in one run?

Yes. Add multiple role names to `roles` and set `maxItems` high enough for the expected reports.

#### Do I need a Built In account?

No. The actor targets public salary pages visible without login.

#### Does it use a browser?

No. The implementation uses HTTP requests and HTML parsing for lower overhead.

#### Can I export to CSV?

Yes. Apify datasets can be downloaded as CSV, JSON, Excel, XML, RSS, and HTML.

### Related scrapers

Other automation-lab actors that pair well with salary intelligence:

- https://apify.com/automation-lab/builtin-jobs-scraper
- https://apify.com/automation-lab/builtin-companies-scraper
- https://apify.com/automation-lab/google-jobs-scraper

### Changelog

Initial version:

- HTTP extraction for Built In salary benchmark pages
- Summary benchmark rows
- Recent salary report rows
- Optional related salary rows
- Role and location input helpers

### Support

If a page stops extracting correctly, include the Built In salary URL, actor input, and run ID in your report so the issue can be reproduced quickly.

# Actor input Schema

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

Direct Built In salary benchmark URLs. Use these for exact city/category salary pages.

## `roles` (type: `array`):

Role names to convert into national Built In salary URLs, for example Software Engineer or Data Engineer. Used when start URLs are empty, or in addition to them.

## `locations` (type: `array`):

Use US for national pages. City names such as Austin or Seattle are matched against location links discovered on the role page.

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

Maximum number of salary benchmark/report/related rows to save.

## `maxReportsPerPage` (type: `integer`):

Limits recent anonymous salary report rows extracted from each benchmark page.

## `includeBenchmark` (type: `boolean`):

Save one summary row per salary benchmark page.

## `includeRecentReports` (type: `boolean`):

Save recent anonymous salary reports shown on the salary page.

## `includeRelatedSalaries` (type: `boolean`):

Also extract related role/city salary rows from tables on the page. Turn on for discovery exports.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://builtin.com/salaries/us/software-engineer"
    }
  ],
  "roles": [
    "Software Engineer"
  ],
  "locations": [
    "US"
  ],
  "maxItems": 20,
  "maxReportsPerPage": 20,
  "includeBenchmark": true,
  "includeRecentReports": true,
  "includeRelatedSalaries": false
}
```

# 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://builtin.com/salaries/us/software-engineer"
        }
    ],
    "roles": [
        "Software Engineer"
    ],
    "locations": [
        "US"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/builtin-salaries-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://builtin.com/salaries/us/software-engineer" }],
    "roles": ["Software Engineer"],
    "locations": ["US"],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/builtin-salaries-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://builtin.com/salaries/us/software-engineer"
    }
  ],
  "roles": [
    "Software Engineer"
  ],
  "locations": [
    "US"
  ]
}' |
apify call automation-lab/builtin-salaries-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Built In Salaries Scraper",
        "description": "Scrape Built In salary benchmarks, compensation ranges, and recent salary reports by role and location.",
        "version": "0.1",
        "x-build-id": "4pv65ItwW8bMdcQVm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~builtin-salaries-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-builtin-salaries-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~builtin-salaries-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-builtin-salaries-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~builtin-salaries-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-builtin-salaries-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": "Built In salary URLs",
                        "type": "array",
                        "description": "Direct Built In salary benchmark URLs. Use these for exact city/category salary pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "roles": {
                        "title": "Role names or slugs",
                        "type": "array",
                        "description": "Role names to convert into national Built In salary URLs, for example Software Engineer or Data Engineer. Used when start URLs are empty, or in addition to them.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Use US for national pages. City names such as Austin or Seattle are matched against location links discovered on the role page.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum dataset rows",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of salary benchmark/report/related rows to save.",
                        "default": 20
                    },
                    "maxReportsPerPage": {
                        "title": "Maximum recent reports per page",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Limits recent anonymous salary report rows extracted from each benchmark page.",
                        "default": 20
                    },
                    "includeBenchmark": {
                        "title": "Include benchmark summary rows",
                        "type": "boolean",
                        "description": "Save one summary row per salary benchmark page.",
                        "default": true
                    },
                    "includeRecentReports": {
                        "title": "Include recent salary report rows",
                        "type": "boolean",
                        "description": "Save recent anonymous salary reports shown on the salary page.",
                        "default": true
                    },
                    "includeRelatedSalaries": {
                        "title": "Include related salary table rows",
                        "type": "boolean",
                        "description": "Also extract related role/city salary rows from tables on the page. Turn on for discovery exports.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```