# Monster Jobs Scraper (`khadinakbar/monster-jobs-scraper`) Actor

Scrape Monster.com jobs with salary, company, location, posted date, and apply URLs. HTTP-only, no login, MCP-ready. Charged $0.005 per returned job.

- **URL**: https://apify.com/khadinakbar/monster-jobs-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Jobs, MCP servers, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 job founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Monster Jobs Scraper

Scrape **Monster.com** job listings by keyword and location — title, company, location, salary, employment type, posted date, full description, and apply URL. HTTP-only (no login, no browser), residential-proxy backed to clear Monster's DataDome protection, and **MCP-ready** for AI agents.

### What you get

Give it a search query (and optionally a location), get back clean, flat JSON — one record per job. Built for recruiters, job-board aggregators, ATS pipelines, salary-benchmark analysts, and AI agents that need live US job-market data.

| Field | Description |
|-------|-------------|
| `title` | Job title |
| `company` | Hiring company / employer |
| `companyUrl` | Company page link (when available) |
| `location` | Human-readable location text |
| `city` / `state` / `country` | Parsed location parts |
| `isRemote` | Remote flag when the listing indicates it |
| `salaryText` | Raw salary text as shown on Monster |
| `salaryMin` / `salaryMax` | Parsed salary bounds |
| `salaryCurrency` / `salaryPeriod` | e.g. `USD`, `year` |
| `employmentType` | Full-Time, Part-Time, Contract, … |
| `postedAt` | Posting date (ISO 8601) |
| `postedAtText` | Raw recency text (e.g. "3 days ago") |
| `description` | Plain-text description (full text when detail enrichment is on) |
| `jobUrl` | Canonical Monster.com job URL |
| `applyUrl` | Direct apply URL when available |
| `jobId`, `source`, `scrapedAt` | Identifier, `monster.com`, ISO timestamp |

### When to use this actor

- **Use it for** Monster.com job postings: sourcing candidates' target roles, salary benchmarking, market research, feeding an ATS or a job aggregator.
- **Do not use it for** LinkedIn, Indeed, Glassdoor, Google Jobs, ZipRecruiter, Wellfound, StepStone, or Naukri — each has its own dedicated scraper in this portfolio (see **Related actors** below).

### Input

```json
{
  "searchQuery": "software engineer",
  "location": "New York, NY",
  "maxResults": 50,
  "enrichDetails": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

| Input | Type | Default | Notes |
|-------|------|---------|-------|
| `searchQuery` | string | `software engineer` | Role or keyword. Ignored if Start URLs are set. |
| `location` | string | `""` | City, state, or "Remote". Blank = nationwide (US). |
| `maxResults` | integer | `50` | Hard cap on jobs returned **and billed** (1–1000). |
| `enrichDetails` | boolean | `true` | Visit each job's detail page for the full description and extra fields. |
| `startUrls` | array | — | Paste Monster search or job-detail URLs directly. |
| `maxConcurrency` | integer | `8` | Parallelism (1–20). Lower it if you see blocks. |
| `proxyConfiguration` | object | residential | Residential proxies strongly recommended — Monster uses DataDome. |

You can also paste **Start URLs** like `https://www.monster.com/jobs/search?q=nurse&where=Texas` or a job-detail URL, and the actor auto-detects the type.

### Pricing — pay per result

This actor uses **pay-per-event** pricing (plus optional usage-based billing):

| Event | Price |
|-------|-------|
| Actor start | $0.00005 |
| Job found | **$0.005** per returned job |
| Job detail enriched | $0.003 per job (only when `enrichDetails` is on) |

A typical run of 50 enriched jobs costs about **$0.40**. With `enrichDetails: false` the same run is about **$0.25**. The actor stops before charging past `maxResults`, prints an upfront cost cap, and reports the estimated charge in the run summary.

### Output

Results land in the default dataset, one row per job. A `RUN_SUMMARY` object in the key-value store reports counts, charges, and health signals (blocks, empty pages, salvaged records).

```json
{
  "jobId": "abc-123",
  "title": "Senior Software Engineer",
  "company": "Acme Corp",
  "location": "New York, NY",
  "salaryText": "$120,000 - $150,000 per year",
  "salaryMin": 120000,
  "salaryMax": 150000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "employmentType": "Full-Time",
  "postedAt": "2026-06-10T00:00:00.000Z",
  "description": "We are hiring a senior engineer to ...",
  "jobUrl": "https://www.monster.com/job-openings/senior-software-engineer-new-york-ny--abc-123",
  "applyUrl": "https://www.monster.com/job-openings/...",
  "source": "monster.com",
  "scrapedAt": "2026-06-14T12:00:00.000Z"
}
```

### Use with AI agents (MCP)

This actor is optimized for the Model Context Protocol. Exposed via Apify MCP as `apify--monster-jobs-scraper`, an agent can call it with a query and location and receive structured job records. Connect at `https://mcp.apify.com?tools=khadinakbar/monster-jobs-scraper`.

### How it works

The actor reads Monster.com's server-rendered search pages and extracts the embedded `__NEXT_DATA__` payload (with a JSON-LD fallback), so there's no fragile HTML scraping and no browser overhead. Monster is protected by DataDome; the actor uses Apify residential proxies, a consistent session pool, and browser-like headers to fetch reliably, retiring and rotating sessions on any block. Failed detail enrichments fall back to the listing-level record so no job is silently lost.

### Reliability notes

- **Residential proxies are required** for consistent results. Datacenter or local IPs are usually blocked by DataDome.
- If a run returns 0 jobs because every request was blocked, the run fails clearly with a DataDome message rather than reporting a misleading empty success.
- Genuine zero-result searches finish successfully with an empty dataset and a clear status message.

### Related actors (jobs cluster)

- `khadinakbar/linkedin-jobs-scraper` — LinkedIn jobs with salary & skills
- `khadinakbar/indeed-job-scraper` — Indeed job details
- `khadinakbar/glassdoor-jobs-scraper` — Glassdoor jobs
- `khadinakbar/google-jobs-scraper` — Google Jobs aggregator
- `khadinakbar/wellfound-jobs-scraper` — startup jobs with equity
- `khadinakbar/stepstone-jobs-scraper` — StepStone (DACH) jobs
- `khadinakbar/naukri-jobs-scraper` — Naukri (India) jobs
- `khadinakbar/visa-sponsored-jobs-scraper` — visa-sponsored roles

### FAQ

**Does it need a Monster.com login?** No. It scrapes public search and job pages only.

**Which countries?** Monster.com (US) is the primary target. Use the `location` field for US cities/states; international Monster domains may work via Start URLs but are not guaranteed.

**Why residential proxies?** Monster uses DataDome bot management. Residential IPs with consistent sessions are needed to fetch reliably.

**Can I get full descriptions?** Yes — keep `enrichDetails: true` (the default). It visits each job's detail page for the full text.

### Legal

This actor collects only publicly available information from Monster.com. You are responsible for using the data in compliance with Monster.com's Terms of Use, applicable laws (including GDPR/CCPA), and any data-protection obligations. Do not use scraped personal data for unlawful purposes. This actor is not affiliated with or endorsed by Monster Worldwide, Inc.

# Actor input Schema

## `searchQuery` (type: `string`):

Use this when you want Monster.com jobs for a role or keyword. Enter plain text such as 'software engineer' or 'registered nurse'. Defaults to 'software engineer'. This is not a Monster URL; paste URLs into Start URLs instead.

## `location` (type: `string`):

Use this to limit jobs to a city, state, or area. Enter text such as 'New York, NY', 'Texas', or 'Remote'. Defaults to blank, which returns jobs across the United States. This is not a country code.

## `maxResults` (type: `integer`):

Use this to cap the number of Monster jobs returned and billed in one run. Accepts 1 to 1000; the default is 50. The actor stops before charging past this limit. This is not a page count.

## `enrichDetails` (type: `boolean`):

Use this to fetch each job's full description and extra fields from its Monster detail page. When true, results are richer but each enriched job adds a small detail charge. Defaults to true. When false, only listing-level fields are returned.

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

Use this when you already have Monster search or job-detail URLs. Accepts URLs like https://www.monster.com/jobs/search?q=nurse\&where=Texas or https://www.monster.com/job-openings/... . When set, Search query and Location are ignored. This is not for LinkedIn, Indeed, or Glassdoor URLs.

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

Use this to tune how many requests run in parallel. Accepts 1 to 20; the default is 8. Lower it if you see blocks; raise it for faster large runs. This does not change how many jobs are returned.

## `debugDumpHtml` (type: `boolean`):

Use this only when troubleshooting empty results. When true, raw HTML of blocked or empty pages is saved to the key-value store under DEBUG- keys. Defaults to false. This adds storage but no extra billing events.

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

Use this to choose proxies. Monster.com is protected by DataDome, so Apify residential proxies are strongly recommended and enabled by default. Datacenter proxies will usually be blocked. This is required for reliable results.

## Actor input object example

```json
{
  "searchQuery": "software engineer",
  "location": "New York, NY",
  "maxResults": 50,
  "enrichDetails": true,
  "maxConcurrency": 8,
  "debugDumpHtml": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Structured Monster.com job records with title, company, location, salary, posted date, description, and apply URL.

## `summary` (type: `string`):

Run-level totals, warnings, cost counters, and input context.

# 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 = {
    "searchQuery": "software engineer",
    "location": "New York, NY",
    "maxResults": 50,
    "enrichDetails": true,
    "maxConcurrency": 8,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/monster-jobs-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 = {
    "searchQuery": "software engineer",
    "location": "New York, NY",
    "maxResults": 50,
    "enrichDetails": True,
    "maxConcurrency": 8,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/monster-jobs-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 '{
  "searchQuery": "software engineer",
  "location": "New York, NY",
  "maxResults": 50,
  "enrichDetails": true,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/monster-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Monster Jobs Scraper",
        "description": "Scrape Monster.com jobs with salary, company, location, posted date, and apply URLs. HTTP-only, no login, MCP-ready. Charged $0.005 per returned job.",
        "version": "0.7",
        "x-build-id": "UysZk3AKlwoC4s0Zw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~monster-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-monster-jobs-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/khadinakbar~monster-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-monster-jobs-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/khadinakbar~monster-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-monster-jobs-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": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Use this when you want Monster.com jobs for a role or keyword. Enter plain text such as 'software engineer' or 'registered nurse'. Defaults to 'software engineer'. This is not a Monster URL; paste URLs into Start URLs instead.",
                        "default": "software engineer"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Use this to limit jobs to a city, state, or area. Enter text such as 'New York, NY', 'Texas', or 'Remote'. Defaults to blank, which returns jobs across the United States. This is not a country code.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Use this to cap the number of Monster jobs returned and billed in one run. Accepts 1 to 1000; the default is 50. The actor stops before charging past this limit. This is not a page count.",
                        "default": 50
                    },
                    "enrichDetails": {
                        "title": "Fetch job detail pages",
                        "type": "boolean",
                        "description": "Use this to fetch each job's full description and extra fields from its Monster detail page. When true, results are richer but each enriched job adds a small detail charge. Defaults to true. When false, only listing-level fields are returned.",
                        "default": true
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Use this when you already have Monster search or job-detail URLs. Accepts URLs like https://www.monster.com/jobs/search?q=nurse&where=Texas or https://www.monster.com/job-openings/... . When set, Search query and Location are ignored. This is not for LinkedIn, Indeed, or Glassdoor URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Use this to tune how many requests run in parallel. Accepts 1 to 20; the default is 8. Lower it if you see blocks; raise it for faster large runs. This does not change how many jobs are returned.",
                        "default": 8
                    },
                    "debugDumpHtml": {
                        "title": "Save debug HTML",
                        "type": "boolean",
                        "description": "Use this only when troubleshooting empty results. When true, raw HTML of blocked or empty pages is saved to the key-value store under DEBUG- keys. Defaults to false. This adds storage but no extra billing events.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use this to choose proxies. Monster.com is protected by DataDome, so Apify residential proxies are strongly recommended and enabled by default. Datacenter proxies will usually be blocked. This is required for reliable results.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
