# Salary.com Scraper (`haketa/salary-com-scraper`) Actor

Scrape salary benchmark data from Salary.com. Extract median salary, percentile ranges (10th-90th), experience-level pay, hourly/monthly rates and state-by-state breakdowns for any job title across 60+ categories.

- **URL**: https://apify.com/haketa/salary-com-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Developer tools, Automation, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

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

## Salary.com Scraper

Extract salary benchmark data from **[Salary.com](https://www.salary.com)** — the compensation platform used by **10,000+ companies** for pay decisions. Get median salaries, percentile ranges (10th–90th), experience-level pay, hourly/monthly rates and state-by-state breakdowns across **60+ job categories** from CEO to registered nurse.

### Why use Salary.com Scraper?

Salary.com is the standard reference for compensation benchmarking. While Levels.fyi covers only tech roles at big companies, Salary.com spans every industry — healthcare, construction, education, finance, legal, manufacturing and more. This is the only Salary.com scraper on Apify Store.

### What data can you extract?

#### Per job title (single page)

Every benchmark page provides: job title, median annual salary, percentile distribution (10th, 25th, 50th, 75th, 90th), hourly rate, monthly and weekly pay, annual bonus, total compensation, experience-level breakdown (entry through expert), related job titles with salaries, job category, data effective date, and job description.

#### State breakdowns (optional)

Enable `scrapeStateData` to get salary data for all 50 US states per job title. Compare what a Software Engineer earns in California vs Texas vs New York — essential for geographic pay analysis and relocation decisions.

### How much does Salary.com Scraper cost?

| Mode | Speed | Approximate cost |
|---|---|---|
| Per job title | ~10s per title | **~$1 per 100 titles** |
| With state data | +50 requests per title | **~$10 per 100 titles** |

Playwright browser required for Cloudflare bypass — runs on Apify's managed infrastructure.

### Example output

```json
{
  "jobTitle": "Software Engineer I",
  "slug": "software-engineer-i",
  "category": "IT - Computers, Software",
  "medianSalary": 81660,
  "percentile10": 68455,
  "percentile25": 74748,
  "percentile75": 87772,
  "percentile90": 93337,
  "hourlyRate": 39,
  "annualBonus": 7668,
  "totalCompensation": 89328,
  "description": "How much does a Software Engineer I make? The average annual salary of Software Engineer I in the United States is $81,660 or $39 per hour, ranging from $68,455 to $93,337.",
  "sourceUrl": "https://www.salary.com/research/salary/benchmark/software-engineer-i-salary"
}
````

With `scrapeStateData` enabled, additional field:

```json
{
  "stateData": [
    { "state": "California", "stateCode": "CA", "salary": 95200 },
    { "state": "New York", "stateCode": "NY", "salary": 92800 },
    { "state": "Washington", "stateCode": "WA", "salary": 91500 },
    { "state": "Texas", "stateCode": "TX", "salary": 78900 }
  ]
}
```

### Input parameters

#### Quick start — just add job titles and run

```json
{
  "jobTitles": ["software-engineer-i", "registered-nurse", "project-manager"],
  "maxTitles": 10
}
```

#### Full input reference

| Parameter | Type | Default | Description |
|---|---|---|---|
| `benchmarkUrls` | array | `[]` | Direct Salary.com benchmark URLs — overrides jobTitles |
| `jobTitles` | array | `[]` | Job title slugs: `software-engineer-i`, `chief-executive-officer` |
| `scrapeStateData` | boolean | `false` | Fetch salary for all 50 states per title |
| `states` | array | `[]` | Limit to specific states: `ca`, `tx`, `ny`. Empty = all 50 |
| `maxTitles` | integer | `50` | Max job titles to scrape. 0 = unlimited |
| `requestDelay` | integer | `800` | Delay between requests (ms) |
| `maxConcurrency` | integer | `1` | Parallel requests (1-3) |

#### Job title slug format

Salary.com uses specific slugs that may not match the exact job title. **The safest approach is to copy the slug directly from a Salary.com URL.** To find the correct slug:

1. Go to [salary.com](https://www.salary.com) and search for a job title
2. Click on the benchmark result
3. Copy the slug from the URL: `salary.com/research/salary/benchmark/{THIS-PART}-salary`

**Verified working slugs:**

`software-engineer-i` · `software-engineer-ii` · `software-engineer-iii` · `chief-executive-officer` · `marketing-manager` · `accountant-i` · `nurse-practitioner` · `human-resources-manager` · `mechanical-engineer-i` · `teacher-elementary-school` · `web-developer` · `graphic-designer` · `sales-manager` · `staff-accountant` · `operations-manager`

**Important:** Not all job titles use obvious slugs. For example, `project-manager`, `data-scientist`, `civil-engineer` and `financial-analyst` return 404 — these roles may use different slugs like `project-manager-it` or `data-scientist-i`, or they may only exist under the `/alternate/` path. The scraper automatically skips invalid slugs and logs a warning. When in doubt, use `benchmarkUrls` with the full URL copied from Salary.com.

#### Direct URL examples (recommended for accuracy)

```json
{
  "benchmarkUrls": [
    "https://www.salary.com/research/salary/benchmark/software-engineer-i-salary",
    "https://www.salary.com/research/salary/benchmark/chief-executive-officer-salary",
    "https://www.salary.com/research/salary/benchmark/nurse-practitioner-salary"
  ]
}
```

#### State comparison example

```json
{
  "jobTitles": ["software-engineer-i"],
  "scrapeStateData": true,
  "states": ["ca", "tx", "ny", "wa", "co"]
}
```

### How to scrape Salary.com data

1. Click **Try for free** to open Salary.com Scraper in Apify Console
2. Enter job title slugs (e.g. `software-engineer-i`)
3. Enable `scrapeStateData` for geographic salary comparison
4. Click **Start** and download results as JSON, CSV or Excel

Run programmatically via [Apify API](https://docs.apify.com/api/v2), schedule monthly runs for trend tracking, or integrate with Zapier, Make, Google Sheets and 100+ platforms.

### Use cases for Salary.com data

**Compensation benchmarking** — HR teams compare their pay ranges against market data. The 25th–75th percentile range is the standard for setting salary bands.

**Offer calibration** — Recruiters use percentile data to craft competitive offers. A 50th percentile offer is market rate; 75th percentile wins competitive candidates.

**Geographic pay analysis** — Compare the same role across states to set location-based pay differentials. Essential for remote-first companies with distributed teams.

**Pay equity audits** — Compensation analysts benchmark internal salaries against market rates to identify underpaid roles or departments.

**Cost-of-hire forecasting** — Finance teams estimate headcount costs using market salary data for budget planning.

**Career platform data** — Job boards, career coaches and salary comparison tools use benchmark data to power their recommendation engines.

**Market research** — Consulting firms and analysts track salary trends across industries for client reports and publications.

**SMB alternative to CompAnalyst** — Small businesses that can't afford Salary.com's enterprise product ($5K+/year) use this scraper for the same public benchmark data at a fraction of the cost.

### Output fields reference

| Field | Description |
|---|---|
| `jobTitle` | Full job title |
| `slug` | URL identifier |
| `category` | Job category |
| `asOfDate` | Data effective date |
| `medianSalary` | 50th percentile annual salary |
| `percentile10` | 10th percentile salary |
| `percentile25` | 25th percentile salary |
| `percentile75` | 75th percentile salary |
| `percentile90` | 90th percentile salary |
| `hourlyRate` | Hourly equivalent |
| `monthlyPay` | Monthly salary |
| `weeklyPay` | Weekly salary |
| `annualBonus` | Annual bonus amount |
| `totalCompensation` | Base + bonus total |
| `experienceLevels` | Pay by experience (entry → expert) |
| `stateData` | State-by-state salaries (50 states) |
| `relatedJobs` | Similar titles with salaries |
| `description` | Job description text |
| `sourceUrl` | Salary.com page URL |

### Integrations

Salary.com Scraper works with the full Apify ecosystem: API access from Python/Node.js/PHP, webhooks, Google Sheets export, Zapier/Make automation, and Slack/email notifications. Schedule monthly runs to track salary trends over time.

### Important: Cloudflare protection

Salary.com uses Cloudflare bot protection. The scraper uses Playwright (real browser) to bypass this automatically. No proxy needed for most cases, but if you experience blocks, enable Apify proxy in the input settings.

### Limitations

- US salary data only (Salary.com focuses on the United States)
- **Job title slugs must match Salary.com's exact URL format** — not all job titles use obvious slugs. Some roles use level suffixes like `-i`, `-ii`, `-iii`. The scraper logs a warning and skips invalid slugs automatically
- For guaranteed accuracy, use `benchmarkUrls` with full URLs copied from Salary.com
- State data requires 50 additional requests per job title — increases run time significantly
- Some fields (monthlyPay, weeklyPay, experienceLevels) depend on page content and may be null when data is only in JSON-LD
- Data is updated monthly by Salary.com — check the page title for the effective date

# Actor input Schema

## `benchmarkUrls` (type: `array`):

Direct Salary.com benchmark page URLs. Example: 'https://www.salary.com/research/salary/benchmark/software-engineer-i-salary'. If provided, jobTitles input is ignored.

## `jobTitles` (type: `array`):

Job title slugs matching Salary.com URL format. Examples: 'chief-executive-officer', 'software-engineer-i', 'registered-nurse', 'project-manager'. The actor builds the full URL automatically. Ignored if benchmarkUrls is provided.

## `scrapeStateData` (type: `boolean`):

Fetch salary data for all 50 US states per job title. Increases run time significantly (50 extra requests per title).

## `states` (type: `array`):

Limit state scraping to specific states. Use 2-letter codes: 'ca', 'tx', 'ny'. Leave empty for all 50 states. Only used when scrapeStateData is enabled.

## `maxTitles` (type: `integer`):

Maximum job titles to scrape. Set 0 for unlimited.

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

Proxy settings. Datacenter proxies usually work fine for Salary.com.

## `requestDelay` (type: `integer`):

Delay between requests in milliseconds.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep at 1-3.

## Actor input object example

```json
{
  "benchmarkUrls": [],
  "jobTitles": [
    "software-engineer-i"
  ],
  "scrapeStateData": false,
  "states": [],
  "maxTitles": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestDelay": 800,
  "maxConcurrency": 1
}
```

# Actor output Schema

## `jobTitle` (type: `string`):

Full job title

## `slug` (type: `string`):

URL slug identifier

## `category` (type: `string`):

Job category

## `asOfDate` (type: `string`):

Data effective date

## `medianSalary` (type: `string`):

50th percentile annual salary

## `percentile10` (type: `string`):

10th percentile salary

## `percentile25` (type: `string`):

25th percentile salary

## `percentile75` (type: `string`):

75th percentile salary

## `percentile90` (type: `string`):

90th percentile salary

## `hourlyRate` (type: `string`):

Equivalent hourly rate

## `monthlyPay` (type: `string`):

Monthly salary

## `experienceLevels` (type: `string`):

Pay by experience level (JSON)

## `stateData` (type: `string`):

State-by-state salaries (JSON)

## `sourceUrl` (type: `string`):

Salary.com benchmark page URL

## `scrapedAt` (type: `string`):

ISO timestamp

# 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 = {
    "benchmarkUrls": [],
    "jobTitles": [
        "software-engineer-i"
    ],
    "states": [],
    "maxTitles": 1,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/salary-com-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 = {
    "benchmarkUrls": [],
    "jobTitles": ["software-engineer-i"],
    "states": [],
    "maxTitles": 1,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/salary-com-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 '{
  "benchmarkUrls": [],
  "jobTitles": [
    "software-engineer-i"
  ],
  "states": [],
  "maxTitles": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/salary-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Salary.com Scraper",
        "description": "Scrape salary benchmark data from Salary.com. Extract median salary, percentile ranges (10th-90th), experience-level pay, hourly/monthly rates and state-by-state breakdowns for any job title across 60+ categories.",
        "version": "0.0",
        "x-build-id": "Z2BRYUw7c1IF9gwmU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~salary-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-salary-com-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/haketa~salary-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-salary-com-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/haketa~salary-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-salary-com-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": {
                    "benchmarkUrls": {
                        "title": "Benchmark URLs",
                        "type": "array",
                        "description": "Direct Salary.com benchmark page URLs. Example: 'https://www.salary.com/research/salary/benchmark/software-engineer-i-salary'. If provided, jobTitles input is ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobTitles": {
                        "title": "Job Title Slugs",
                        "type": "array",
                        "description": "Job title slugs matching Salary.com URL format. Examples: 'chief-executive-officer', 'software-engineer-i', 'registered-nurse', 'project-manager'. The actor builds the full URL automatically. Ignored if benchmarkUrls is provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeStateData": {
                        "title": "Scrape State Breakdowns",
                        "type": "boolean",
                        "description": "Fetch salary data for all 50 US states per job title. Increases run time significantly (50 extra requests per title).",
                        "default": false
                    },
                    "states": {
                        "title": "Specific States (optional)",
                        "type": "array",
                        "description": "Limit state scraping to specific states. Use 2-letter codes: 'ca', 'tx', 'ny'. Leave empty for all 50 states. Only used when scrapeStateData is enabled.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxTitles": {
                        "title": "Max Job Titles",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum job titles to scrape. Set 0 for unlimited.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Datacenter proxies usually work fine for Salary.com."
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay between requests in milliseconds.",
                        "default": 800
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Parallel requests. Keep at 1-3.",
                        "default": 1
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
