# Dice Jobs Scraper (`fetch_cat/dice-jobs-scraper`) Actor

Scrape public Dice tech jobs by keyword, location, or Dice search URL. Export titles, companies, salaries, work models, descriptions, and links.

- **URL**: https://apify.com/fetch\_cat/dice-jobs-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.11 / 1,000 dice job listing saveds

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

## Dice Jobs Scraper

Extract public Dice job listings, hiring company details, locations, salaries, work models, and optional job descriptions from Dice.com.

### What does Dice Jobs Scraper do?

Dice Jobs Scraper helps you collect structured job listings from Dice without copying and pasting search results by hand.

It can search Dice by keyword and location, or it can start from Dice search URLs that you already prepared.

The actor returns clean dataset rows with the job title, company, Dice job URL, workplace type, remote signal, employment type, salary text when Dice provides it, and timestamps.

Turn on detail extraction when you need fuller job descriptions and detected technology skills.

### Who is it for?

Recruiters use it to monitor roles by skill, location, and company.

Staffing agencies use it to build lead lists and track new demand in their specialties.

Labor-market analysts use it to measure tech hiring demand across keywords and geographies.

Sales teams use it to find companies currently hiring for technologies their product supports.

Job seekers use it to export Dice searches into spreadsheets for tracking and comparison.

### Why use this Dice scraper?

✅ Save job data in a structured dataset.

✅ Search by keyword and location.

✅ Capture public Dice URLs for follow-up.

✅ Export to CSV, JSON, Excel, Google Sheets, or your own API.

✅ Keep the first run small with a low default item limit.

✅ Use optional detail pages only when you need richer descriptions.

### What Dice data can I extract?

| Field | Description |
| --- | --- |
| `id` | Dice job identifier when available |
| `title` | Job title |
| `companyName` | Hiring company name |
| `companyLogoUrl` | Public company logo URL when available |
| `location` | Dice location display text |
| `isRemote` | Remote flag when Dice exposes it |
| `workplaceTypes` | Work model labels such as Remote, Hybrid, or On-Site |
| `employmentType` | Full-time, contract, or other Dice employment type |
| `employerType` | Direct hire or related employer type |
| `postedAt` | Dice posted timestamp |
| `modifiedAt` | Dice modified timestamp |
| `summary` | Short listing summary |
| `detailsPageUrl` | Public Dice job detail URL |
| `easyApply` | Dice easy apply signal |
| `salary` | Salary text when visible in search results |
| `skills` | Detected skills from the detail page when enabled |
| `description` | Fuller job description when detail extraction is enabled |
| `searchUrl` | Dice search URL used for the item |
| `scrapedAt` | Time the item was saved |

### How much does it cost to scrape Dice jobs?

The actor uses pay-per-event pricing.

You pay a small start event for each run and a per-job event for each saved Dice listing.

At the standard BRONZE tier, saved Dice listings are priced at about $0.18 per 1,000 jobs, plus the $0.005 run start event.

The default input saves only 20 jobs so you can test the dataset shape before running larger searches.

A typical small run costs cents, depending on your selected item limit and whether you enable detail pages.

For high-volume monitoring, start with search pages only, then enable detail pages for the highest-value searches.

### How to scrape Dice job listings

1. Open the actor on Apify.
2. Enter a job keyword such as `software engineer`, `data engineer`, or `cybersecurity`.
3. Enter a Dice location such as `Remote`, `New York`, or `Austin`.
4. Set `Maximum jobs` to the number of listings you want.
5. Keep `Open detail pages` off for a fast first run.
6. Start the actor.
7. Export the dataset to CSV, JSON, Excel, Google Sheets, or through the Apify API.

### Input options

#### Job keywords

The main Dice search phrase.

Examples:

- `software engineer`
- `data engineer`
- `product manager`
- `cybersecurity analyst`
- `salesforce developer`

#### Location

The Dice location text.

Examples:

- `Remote`
- `United States`
- `New York`
- `San Francisco`
- `Austin`

#### Search radius

Distance around the location.

The default is 20 miles.

#### Maximum jobs

The maximum number of dataset items to save.

Use a small value for testing.

Increase it for production monitoring.

#### Page size

The number of Dice results requested per page.

The default is 20.

#### Dice search URLs

Use `startUrls` when you already have a Dice search page with filters.

If `startUrls` is provided, the actor uses those URLs instead of the keyword and location fields.

#### Open detail pages

Enable `includeDetails` when you want fuller job descriptions and detected skills.

This is slower because the actor opens each public job detail page.

### Example input

```json
{
  "query": "software engineer",
  "location": "Remote",
  "radius": 20,
  "radiusUnit": "mi",
  "maxItems": 20,
  "pageSize": 20,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### Example input with Dice search URLs

```json
{
  "startUrls": [
    {
      "url": "https://www.dice.com/jobs?q=data%20engineer&location=Remote&radius=30&radiusUnit=mi&page=1&pageSize=20"
    }
  ],
  "maxItems": 50,
  "includeDetails": true
}
```

### Example output

```json
{
  "id": "09b88736-b90a-4210-8228-b7e87f1d1f8a",
  "title": "Senior CIAM Software Engineer",
  "companyName": "Zions Bancorporation, N.A.",
  "companyLogoUrl": "https://d3qscgr6xsioh.cloudfront.net/example.png?format=webp",
  "location": "Midvale, Utah, USA",
  "isRemote": false,
  "workplaceTypes": ["On-Site"],
  "employmentType": "Full-time",
  "employerType": "Direct Hire",
  "postedAt": "2026-06-04T00:01:05Z",
  "modifiedAt": "2026-06-28T00:01:43Z",
  "summary": "Zions Bancorporation's Enterprise Technology and Operations team is transforming...",
  "detailsPageUrl": "https://www.dice.com/job-detail/09b88736-b90a-4210-8228-b7e87f1d1f8a",
  "easyApply": false,
  "salary": null,
  "skills": [],
  "description": null,
  "searchUrl": "https://www.dice.com/jobs?q=software+engineer&location=Remote&radius=30&radiusUnit=mi&page=1&pageSize=20",
  "scrapedAt": "2026-06-28T03:36:52.773Z"
}
```

### Tips for better Dice scraping

Use specific keywords when you need relevant results.

Use broader keywords when you need market-size counts or broad hiring coverage.

Keep detail pages disabled for large monitoring runs unless descriptions are required.

Use Dice search URLs for advanced filters you configured directly on Dice.

Deduplicate jobs by `id` or `detailsPageUrl` in downstream workflows.

### Common workflows

#### Recruiting pipeline monitoring

Run the actor every day for a shortlist of technologies and locations.

Export new jobs to a CRM, ATS, or spreadsheet.

#### Sales lead generation

Search for technologies related to your product.

Use hiring companies as buying-intent leads.

#### Labor-market research

Collect jobs by keyword and location.

Analyze work model, salary coverage, and employer mix.

#### Job seeker tracking

Export public Dice jobs to a spreadsheet.

Add application status, notes, and follow-up dates.

### Integrations

Apify datasets integrate with many tools.

You can connect this actor to:

- Google Sheets for recruiter review queues.
- Slack alerts for new job matches.
- Make or Zapier automations.
- Airtable for lead enrichment.
- Snowflake, BigQuery, or S3 through Apify exports.
- Your own backend using the Apify API.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('fetch_cat/dice-jobs-scraper').call({
  query: 'data engineer',
  location: 'Remote',
  maxItems: 50,
  includeDetails: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 3));
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('APIFY_TOKEN')

run = client.actor('fetch_cat/dice-jobs-scraper').call(run_input={
    'query': 'cybersecurity',
    'location': 'Remote',
    'maxItems': 50,
    'includeDetails': False,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~dice-jobs-scraper/runs?token=APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "query": "software engineer",
    "location": "Remote",
    "maxItems": 20,
    "includeDetails": false
  }'
```

### MCP usage

Use the Apify MCP server to run this actor from AI tools.

MCP URL:

```text
https://mcp.apify.com/?tools=fetch_cat/dice-jobs-scraper
```

Claude Code setup:

```bash
claude mcp add apify-dice "https://mcp.apify.com/?tools=fetch_cat/dice-jobs-scraper"
```

Claude Desktop configuration:

```json
{
  "mcpServers": {
    "apify-dice": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/dice-jobs-scraper"
    }
  }
}
```

Example prompts:

- "Run Dice Jobs Scraper for data engineer roles in Remote and summarize the top hiring companies."
- "Collect 50 cybersecurity jobs from Dice and group them by workplace type."
- "Find companies hiring Salesforce developers on Dice and export the dataset."

### Scheduling

You can schedule this actor in Apify to run daily, weekly, or monthly.

For monitoring new demand, daily schedules with small keyword sets usually work best.

For market reports, weekly or monthly runs may be enough.

### Data quality notes

Dice controls which fields are visible on each public listing.

Some jobs do not show salary.

Some jobs have short summaries until detail extraction is enabled.

Remote flags and workplace labels are returned as Dice exposes them.

### FAQ and troubleshooting

#### Why did I get fewer jobs than requested?

Dice may have fewer public results for your keyword, filters, or page range.

Try a broader keyword or a wider location.

#### Why is `description` empty?

Detail pages are only fetched when `includeDetails` is true.

Keep it false for faster runs and true when full descriptions are required.

#### Why is salary missing?

Dice does not show salary for every job.

The actor saves salary text only when it is visible in the public listing data.

### Legality and responsible use

This actor extracts publicly available Dice job listing data.

You are responsible for using the data in compliance with applicable laws, Dice terms, and privacy requirements.

Do not use scraped data for spam, discrimination, or unlawful employment practices.

### Performance guidance

Start with `maxItems` between 10 and 50 while you validate your workflow.

Use larger runs after checking the dataset shape.

Disable detail extraction for high-volume search monitoring.

Enable detail extraction only when descriptions or skill detection matter.

### Related actors

- [Ashby Jobs Scraper](https://apify.com/fetch_cat/ashby-jobs-scraper) for Ashby-hosted company career pages.
- [ATS Jobs Scraper](https://apify.com/fetch_cat/ats-jobs-scraper) for broad ATS job collection.
- [Hacker News Search Scraper](https://apify.com/fetch_cat/hacker-news-search-scraper) for tech community and hiring discussions.

### Changelog

#### 0.1.0

Initial version with Dice search scraping, optional detail pages, salary text, remote/workplace fields, and job URL output.

# Actor input Schema

## `query` (type: `string`):

Keywords to search on Dice, such as a job title, skill, or technology.

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

Dice location text, for example Remote, New York, Austin, or United States.

## `radius` (type: `integer`):

Distance around the location to search.

## `radiusUnit` (type: `string`):

Unit for the search radius.

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

Maximum number of job listings to save.

## `pageSize` (type: `integer`):

Dice results to request per search page.

## `includeDetails` (type: `boolean`):

Fetch each job detail page to add a fuller description and detected skills. Leave off for faster runs.

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

Optional Dice /jobs search URLs. If provided, these override keyword and location fields.

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

Optional Apify proxy settings. Datacenter/automatic proxy is usually enough for small public Dice searches.

## Actor input object example

```json
{
  "query": "software engineer",
  "location": "Remote",
  "radius": 20,
  "radiusUnit": "mi",
  "maxItems": 20,
  "pageSize": 20,
  "includeDetails": false,
  "startUrls": [
    {
      "url": "https://www.dice.com/jobs?q=data%20engineer&location=Remote&radius=20&radiusUnit=mi&page=1&pageSize=20"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "software engineer",
    "location": "Remote",
    "radius": 20,
    "radiusUnit": "mi",
    "maxItems": 20,
    "pageSize": 20,
    "includeDetails": false,
    "startUrls": [
        {
            "url": "https://www.dice.com/jobs?q=data%20engineer&location=Remote&radius=20&radiusUnit=mi&page=1&pageSize=20"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/dice-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 = {
    "query": "software engineer",
    "location": "Remote",
    "radius": 20,
    "radiusUnit": "mi",
    "maxItems": 20,
    "pageSize": 20,
    "includeDetails": False,
    "startUrls": [{ "url": "https://www.dice.com/jobs?q=data%20engineer&location=Remote&radius=20&radiusUnit=mi&page=1&pageSize=20" }],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/dice-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 '{
  "query": "software engineer",
  "location": "Remote",
  "radius": 20,
  "radiusUnit": "mi",
  "maxItems": 20,
  "pageSize": 20,
  "includeDetails": false,
  "startUrls": [
    {
      "url": "https://www.dice.com/jobs?q=data%20engineer&location=Remote&radius=20&radiusUnit=mi&page=1&pageSize=20"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/dice-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dice Jobs Scraper",
        "description": "Scrape public Dice tech jobs by keyword, location, or Dice search URL. Export titles, companies, salaries, work models, descriptions, and links.",
        "version": "0.1",
        "x-build-id": "3PHyPqMOZSOJ5Zele"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~dice-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-dice-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/fetch_cat~dice-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-dice-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/fetch_cat~dice-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-dice-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": {
                    "query": {
                        "title": "Job keywords",
                        "type": "string",
                        "description": "Keywords to search on Dice, such as a job title, skill, or technology.",
                        "default": "software engineer"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Dice location text, for example Remote, New York, Austin, or United States.",
                        "default": "Remote"
                    },
                    "radius": {
                        "title": "Search radius",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Distance around the location to search.",
                        "default": 20
                    },
                    "radiusUnit": {
                        "title": "Radius unit",
                        "enum": [
                            "mi",
                            "km"
                        ],
                        "type": "string",
                        "description": "Unit for the search radius.",
                        "default": "mi"
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of job listings to save.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "Page size",
                        "minimum": 10,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Dice results to request per search page.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Open detail pages",
                        "type": "boolean",
                        "description": "Fetch each job detail page to add a fuller description and detected skills. Leave off for faster runs.",
                        "default": false
                    },
                    "startUrls": {
                        "title": "Dice search URLs",
                        "type": "array",
                        "description": "Optional Dice /jobs search URLs. If provided, these override keyword and location fields.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Datacenter/automatic proxy is usually enough for small public Dice searches."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
