# Monster Job Scraper (`solidcode/monster-scraper`) Actor

\[💰 $0.5 / 1K] Extract Monster.com job postings at scale — title, company, salary range, location with verified geo-coordinates, apply links, and full job descriptions. Built for recruiters, market analysts, and ATS/CRM integrations.

- **URL**: https://apify.com/solidcode/monster-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Monster Job Scraper

Pull job postings from Monster.com at scale — titles, companies, salary ranges, street-level
coordinates, apply links, and complete job descriptions. Built for recruiters, talent-market
analysts, and ATS/CRM teams who need a clean, structured feed of live US job listings without
babysitting a scraper.

**This is an unofficial scraper. It is not affiliated with, endorsed by, or connected to
Monster.com, Monster Worldwide, or their operators in any way.** All trademarks belong to their
respective owners.

Paste a Monster search URL — or just type a job title and a city — and get every matching posting
as structured JSON, CSV, or Excel.

### Why This Scraper?

- **32 structured fields per job**, plus an `additionalAttributes` catch-all carrying company size,
  founding date, employer photos, occupation codes, and EEO reporting flags.
- **Street-level coordinates on 98% of postings** — latitude and longitude as real numbers. Jobs
  with no genuine address are left blank instead of being stamped with a country-centre
  placeholder, so you can map results without cleaning out fake pins first.
- **Full job descriptions on every single record** — delivered as both original HTML and
  ready-to-use plain text. No second request, no per-description surcharge.
- **Employer-stated salary only** — `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryUnit` as
  separate typed fields, plus a formatted `$55 - $64 per hour` string. These are the figures the
  employer published, never an algorithmic estimate presented as fact.
- **Remote roles identified reliably** — including the ones Monster's own data leaves unmarked. In
  a 150-job sample the site's raw remote flag caught 3 genuinely-remote postings; this actor
  catches 53.
- **Canonical job titles and normalized company names** — group "SDET", "Software Developer in
  Test" and "Software Design Engineer in Test" together, and reconcile employer name variants
  across postings.
- **Direct apply links on 90% of jobs**, each labelled with its route (`OFFSITE` to the employer's
  own system, or `ONSITE` for Monster's own apply flow) so you know what a candidate will hit.
- **Complete location breakdown** — city, state, ZIP (76% of postings) and country as separate
  fields, plus a pre-joined `"Boston, MA"` display string.
- **Nationwide US coverage** — search any city, ZIP code, or the entire country, with a
  configurable radius, up to 550 jobs per search.

### Use Cases

**Recruitment & Talent Sourcing**
- Track competitor job postings by company, title, and location in near real time
- Build candidate pipelines around roles hiring right now in a target metro
- Spot which employers are expanding into a new city before it becomes public knowledge

**Compensation & Market Research**
- Benchmark employer-published salary ranges by role, seniority, and region
- Track pay movement for a job family across quarters
- Compare hourly versus salaried compensation structures within an industry

**Job Board & Aggregator Feeds**
- Populate a niche job board with fresh, structured listings and working apply links
- Enrich an existing listing database with coordinates, ZIPs, and normalized titles
- Deduplicate reposted listings using stable job IDs and canonical titles

**Labour Market Analytics**
- Map hiring density geographically using per-posting coordinates
- Measure remote versus on-site hiring mix by industry and region
- Monitor posting volume and freshness as a demand indicator

**CRM & ATS Integration**
- Sync live openings into Salesforce, HubSpot, or an internal ATS
- Trigger alerts when a tracked company posts a role matching your criteria
- Feed structured listings into internal matching or recommendation systems

### Getting Started

**Simplest run — type a title and a city:**

```json
{
  "keyword": "registered nurse",
  "location": "Dallas, TX"
}
````

**Paste a search URL straight from your browser:**

```json
{
  "searchUrls": [
    "https://www.monster.com/jobs/search?q=software+developer&where=Boston%2C+MA&rad=30"
  ],
  "maxResults": 200
}
```

**Widen the radius around a metro:**

```json
{
  "keyword": "warehouse associate",
  "location": "Atlanta, GA",
  "radiusMiles": 75,
  "maxResults": 300
}
```

**Several searches at once, collecting everything each one offers:**

```json
{
  "searchUrls": [
    "https://www.monster.com/jobs/search?q=data+analyst&where=Chicago%2C+IL",
    "https://www.monster.com/jobs/search?q=data+analyst&where=Austin%2C+TX",
    "https://www.monster.com/jobs/search?q=data+analyst&where=Denver%2C+CO"
  ],
  "maxResults": 0
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchUrls` | array | — | Monster.com search URLs copied from your address bar. Each is run as a separate search. |
| `keyword` | string | — | Job title or search term, e.g. `python developer`. Use instead of a URL if you prefer. |
| `location` | string | — | City and state, ZIP code, or `United States` for a nationwide search. |
| `radiusMiles` | integer | `30` | How far from the location to search. Ignored for nationwide searches. |

#### Options

| Parameter | Type | Default | Description |
|---|---|---|---|
| `maxResults` | integer | `100` | Maximum jobs per search. Set to `0` for everything the search returns, up to 550. |
| `proxyConfiguration` | object | Apify Proxy | Proxy settings. The default works for virtually every run. |

### Output

Every job is one row. Example record (description shortened for readability):

```json
{
  "jobId": "13274d11-b37e-4ae0-8464-3d2370bbc353",
  "url": "https://www.monster.com/job-openings/software-developer-in-test-sdet-boston-ma--13274d11-b37e-4ae0-8464-3d2370bbc353",
  "title": "Software Developer in Test (SDET)",
  "normalizedTitle": "SDET (Software Design Engineer in Test)",
  "company": "Kforce Inc.",
  "normalizedCompany": "Kforce Inc.",
  "companyLogo": "https://media.newjobs.com/clu/xkfo/xkfocx/branding/81354/Kforce-logo.png",
  "industry": "Financial Services",
  "location": "Boston, MA",
  "city": "Boston",
  "region": "MA",
  "postalCode": "02210",
  "country": "US",
  "latitude": 42.34656,
  "longitude": -71.034458,
  "remote": false,
  "salaryMin": 55.0,
  "salaryMax": 64.0,
  "salaryCurrency": "USD",
  "salaryUnit": "hourly",
  "salaryText": "$55 - $64 per hour",
  "employmentType": "Full-time",
  "descriptionText": "Kforce has a client that is seeking a Software Developer in Test (SDET) in Boston, MA...",
  "applyType": "OFFSITE",
  "applyUrl": "http://www.kforce.com/Jobs/3196~AQG~2181902T1~99/ApplyOnline/",
  "datePosted": "2026-07-13T20:24:25.539Z",
  "dateRecency": "13 days ago",
  "status": "ACTIVE",
  "promoted": true,
  "scrapedAt": "2026-07-26T15:02:11.480Z",
  "additionalAttributes": {
    "companySize": "1,000 to 1,499 employees",
    "foundingDate": "1962",
    "occupationCodes": ["1500137001001"],
    "provider": "kforceftpin"
  }
}
```

#### Core Fields

| Field | Type | Description |
|---|---|---|
| `jobId` | string | Stable unique identifier. Use this to deduplicate across runs. |
| `url` | string | Canonical Monster.com listing URL. |
| `title` | string | Job title exactly as posted. |
| `normalizedTitle` | string | Canonical title for grouping equivalent roles. |
| `status` | string | Listing status, e.g. `ACTIVE`. |
| `promoted` | boolean | Whether the employer paid to promote this listing. |
| `scrapedAt` | string | ISO timestamp of extraction. |

#### Company

| Field | Type | Description |
|---|---|---|
| `company` | string | Hiring company name as posted. |
| `normalizedCompany` | string | Reconciled company name for grouping across postings. |
| `companyLogo` | string | Employer logo image URL. |
| `companyDescription` | string | Employer profile text, plain text. |
| `industry` | string | Industry classification, e.g. `Financial Services`. |

#### Location

| Field | Type | Description |
|---|---|---|
| `location` | string | Pre-joined display string, e.g. `Boston, MA`. |
| `city` | string | City name. |
| `region` | string | State or region code. |
| `postalCode` | string | ZIP code. |
| `country` | string | Country code. |
| `latitude` | number | Latitude. Blank when the posting has no genuine address. |
| `longitude` | number | Longitude. Blank when the posting has no genuine address. |
| `remote` | boolean | Whether the role is remote. |

#### Compensation & Terms

| Field | Type | Description |
|---|---|---|
| `salaryMin` | number | Lower bound of the published range. |
| `salaryMax` | number | Upper bound of the published range. |
| `salaryCurrency` | string | Currency code, e.g. `USD`. |
| `salaryUnit` | string | Pay period, e.g. `hourly`, `yearly`. |
| `salaryText` | string | Formatted display string, e.g. `$55 - $64 per hour`. |
| `employmentType` | string | e.g. `Full-time`, `Contractor`, when the employer states it. |

#### Description & Application

| Field | Type | Description |
|---|---|---|
| `description` | string | Full job description as original HTML. |
| `descriptionText` | string | Same description flattened to readable plain text. |
| `applyType` | string | `OFFSITE` (employer's own system) or `ONSITE` (Monster's apply flow). |
| `applyUrl` | string | Direct application link. Blank for `ONSITE` listings. |
| `datePosted` | string | ISO 8601 posting timestamp. |
| `dateRecency` | string | Human-readable age, e.g. `13 days ago`. |
| `additionalAttributes` | object | Long-tail extras: company size, founding date, employer photos and videos, occupation codes, provider, street address, EEO reporting flags. |

### Tips for Best Results

- **Monster pages through 550 results per search — split by city to get past it.** A search
  matching 250,000 jobs still yields 550. Splitting by location is the fix, and it is clean: six
  metro areas searched at a 30-mile radius returned 300 jobs with **zero duplicates between any
  pair of cities**. Add one entry per city to `searchUrls` and run them together. Keep city
  centres at least twice your radius apart so the circles do not touch.
- **Set `maxResults` to `0` only on narrow searches.** On a broad one you will pay for 550 rows and
  still be told it was truncated. Narrow first, then uncap.
- **Use ZIP codes for tight geographic targeting.** A ZIP plus a small `radiusMiles` is far more
  precise than a city name, which Monster expands to the whole metro area.
- **Deduplicate on `jobId` when running overlapping searches.** Staffing agencies repost the same
  role across several cities, and Monster's relevance ordering repeats listings between pages.
  Within a single run this is handled for you; across runs, key on `jobId`.
- **Salary is present on roughly 20–35% of postings, and that is the honest ceiling.** Most US
  employers simply do not publish pay on Monster. This actor reports only what the employer
  actually stated, so a blank means "not disclosed" rather than "we guessed".
- **`normalizedTitle` beats `title` for analysis.** Raw titles carry employer-specific noise
  ("Sr. SW Developer | Investment Management | Hybrid"); the normalized field collapses them into
  comparable roles.
- **For monitoring, re-run on a schedule and diff on `jobId`.** `datePosted` and `dateRecency` make
  it easy to filter to genuinely new listings rather than reprocessing the whole result set.

### Pricing

**$0.50 per 1,000 results.**

| Results | Cost |
|---------|------|
| 100 | $0.05 |
| 1,000 | $0.50 |
| 10,000 | $5.00 |
| 100,000 | $50.00 |

A "result" is any job row in the output dataset. Platform fees (compute, storage) are additional
and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This scraper collects publicly available job listings. You are responsible for using the data in
compliance with Monster.com's Terms of Service, applicable data protection law (including GDPR and
CCPA where relevant), and employment and fair-hiring regulations in your jurisdiction.

Job postings may contain personal data such as recruiter contact details. Handle any personal data
lawfully: collect only what you need, store it securely, and honour deletion requests. Do not use
this data for discriminatory screening or for unsolicited bulk contact where that is restricted by
law.

**This is an unofficial scraper and is not affiliated with, endorsed by, or connected to
Monster.com or Monster Worldwide.** All trademarks and content belong to their respective owners.

# Actor input Schema

## `searchUrls` (type: `array`):

Paste Monster.com search URLs here. Run the search on Monster.com, set your filters, then copy the URL from your browser's address bar.

## `keyword` (type: `string`):

Search term, for example "registered nurse" or "python developer". Use this instead of a search URL if you prefer. Leave empty to match every job in the location.

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

City and state, ZIP code, or "United States" for a nationwide search. Only used together with the job title above.

## `radiusMiles` (type: `integer`):

How far from the location to search. Ignored for nationwide searches.

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

Maximum jobs to extract per search. Set to 0 for as many as the search returns (up to 550).

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

Proxy settings. The default works for most runs; switch groups only if you see repeated failures.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.monster.com/jobs/search?q=software+developer&where=Boston%2C+MA&rad=30"
  ],
  "keyword": "software developer",
  "location": "Boston, MA",
  "radiusMiles": 30,
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of job postings with company, location, salary and posting date.

## `compensation` (type: `string`):

Salary range, pay period and employment type for each job.

## `company` (type: `string`):

Employer details and how to apply for each job.

# 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 = {
    "searchUrls": [
        "https://www.monster.com/jobs/search?q=software+developer&where=Boston%2C+MA&rad=30"
    ],
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/monster-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 = {
    "searchUrls": ["https://www.monster.com/jobs/search?q=software+developer&where=Boston%2C+MA&rad=30"],
    "maxResults": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/monster-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 '{
  "searchUrls": [
    "https://www.monster.com/jobs/search?q=software+developer&where=Boston%2C+MA&rad=30"
  ],
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call solidcode/monster-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Monster Job Scraper",
        "description": "[💰 $0.5 / 1K] Extract Monster.com job postings at scale — title, company, salary range, location with verified geo-coordinates, apply links, and full job descriptions. Built for recruiters, market analysts, and ATS/CRM integrations.",
        "version": "1.0",
        "x-build-id": "8CAv2w9iorfowZbIS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~monster-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-monster-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/solidcode~monster-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-monster-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/solidcode~monster-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-monster-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": {
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Paste Monster.com search URLs here. Run the search on Monster.com, set your filters, then copy the URL from your browser's address bar.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Job title or keyword",
                        "type": "string",
                        "description": "Search term, for example \"registered nurse\" or \"python developer\". Use this instead of a search URL if you prefer. Leave empty to match every job in the location."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City and state, ZIP code, or \"United States\" for a nationwide search. Only used together with the job title above."
                    },
                    "radiusMiles": {
                        "title": "Search radius (miles)",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How far from the location to search. Ignored for nationwide searches.",
                        "default": 30
                    },
                    "maxResults": {
                        "title": "Max results per search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum jobs to extract per search. Set to 0 for as many as the search returns (up to 550).",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. The default works for most runs; switch groups only if you see repeated failures.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
