# Randstad USA Jobs Scraper (`automation-lab/randstad-usa-jobs-scraper`) Actor

Extract Randstad USA job postings with salaries, locations, descriptions, responsibilities, qualifications, and apply URLs from public pages.

- **URL**: https://apify.com/automation-lab/randstad-usa-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Randstad USA Jobs Scraper

Extract public Randstad USA job postings at scale from search, category, location, and detail pages.

Use this actor to monitor hiring trends, collect staffing-market intelligence, enrich recruiting databases, and track openings from one of the largest staffing brands in the United States.

### What does Randstad USA Jobs Scraper do?

Randstad USA Jobs Scraper turns public pages on `randstadusa.com` into a clean dataset.

It can scrape:

- 🔎 Keyword searches such as `warehouse`, `accounting`, `remote`, or `engineering`
- 📍 Location searches by city, state, or ZIP
- 🧭 Randstad category and search URLs
- 📄 Individual Randstad job detail URLs
- 💵 Salary ranges when Randstad publishes them
- 📝 Descriptions, responsibilities, qualifications, and apply links

### Who is it for?

#### Staffing and recruiting leaders

- 🧑‍💼 Track where Randstad is adding warehouse, manufacturing, finance, healthcare, and office roles.
- 📍 Compare open roles by city, state, ZIP, job type, and salary band.
- 🧭 Build weekly territory briefs for branch managers and regional recruiters.

#### Labor-market intelligence teams

- 📊 Create recurring snapshots of one major staffing brand's public demand signals.
- 💵 Monitor hourly and annual pay ranges by occupation, state, and posting date.
- 🕒 Detect new postings, stale postings, and changes in role mix over time.

#### Sales and business development teams

- 🎯 Identify regions and job categories where employers are actively hiring through Randstad.
- 🔁 Route high-value openings into CRM workflows for staffing, payroll, or HR-tech outreach.
- 🧩 Enrich lead lists with job title, location, job type, salary, and apply URL context.

#### Data and automation teams

- 🏗️ Feed clean Randstad job data into dashboards, warehouses, alerts, and enrichment pipelines.
- 🔌 Use API, webhooks, integrations, or MCP to trigger downstream analysis after every run.

### Why use this actor?

Randstad job pages are public but not convenient for bulk analysis.

This actor normalizes listings into one exportable dataset.

It follows pagination, deduplicates jobs, and can open detail pages for richer fields.

### Key features

- ✅ HTTP-first scraping, no browser overhead
- ✅ Keyword, location, start URL, and detail URL support
- ✅ Pagination across Randstad search result pages
- ✅ Detail extraction from Schema.org JobPosting data
- ✅ Salary min/max/currency/unit normalization
- ✅ Dedupe by reference number, job ID, and URL
- ✅ No-login public data workflow

### Data fields

| Field | Description |
| --- | --- |
| `title` | Job title |
| `company` | Randstad brand or hiring organization |
| `location` | Human-readable city and state |
| `city` | Job city |
| `state` | Job state |
| `zipCode` | ZIP code when available |
| `jobType` | Combined employment type text |
| `employmentType` | Employment type array |
| `category` | Randstad category / occupation |
| `salaryMin` | Minimum salary or hourly pay |
| `salaryMax` | Maximum salary or hourly pay |
| `salaryCurrency` | Salary currency, usually USD |
| `salaryUnit` | Salary unit, such as HOUR or YEAR |
| `salaryText` | Display-ready salary range |
| `postedDate` | Date posted |
| `validThrough` | Posting validity date when available |
| `jobId` | Randstad internal job ID |
| `referenceNumber` | Randstad reference number |
| `description` | Full job description |
| `responsibilities` | Responsibilities text |
| `qualifications` | Qualifications text |
| `skills` | Skills list when exposed |
| `hours` | Shift or work hours |
| `url` | Job detail URL |
| `applyUrl` | Apply URL |
| `sourceUrl` | Search or detail URL that produced the item |
| `scrapedAt` | ISO scrape timestamp |

### How much does it cost to scrape Randstad USA jobs?

This actor uses pay-per-event pricing.

You pay a small start fee and then a per-job result fee. The live Store checkout always shows the final price before a run starts.

| Event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Run started | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |
| Job item extracted | $0.000040905 | $0.00003557 | $0.000027745 | $0.000021342 | $0.000014228 | $0.000010000 |

Example estimated costs before Apify plan discounts or future pricing changes:

| Run size | FREE estimate | BRONZE estimate | Notes |
| --- | ---: | ---: | --- |
| 20 jobs | ~$0.0058 | ~$0.0057 | Good first run or daily smoke monitor |
| 100 jobs | ~$0.0091 | ~$0.0086 | Typical keyword/category export |
| 500 jobs | ~$0.0255 | ~$0.0228 | Larger regional market snapshot |

Free-plan estimate: with the current FREE tier event prices, a 100-job run is about $0.0091, so a small monthly credit can cover many low-volume tests. Use the Apify checkout estimate for exact account-specific pricing.

Use `maxItems` to control run size and cost.

For cheap monitoring, disable detail pages with `includeDetails: false` when titles, locations, dates, and URLs are enough.

### Input overview

The actor accepts four main controls.

- `keywords` — Randstad search keywords
- `locations` — optional city, state, or ZIP searches
- `startUrls` — exact Randstad search/category/detail URLs
- `maxItems` — maximum job postings to save
- `includeDetails` — whether to open detail pages for full text

### Example input: keyword monitoring

```json
{
  "keywords": ["warehouse", "forklift"],
  "maxItems": 100,
  "includeDetails": true
}
````

### Example input: exact Randstad URL

```json
{
  "startUrls": [
    { "url": "https://www.randstadusa.com/jobs/q-warehouse/" }
  ],
  "maxItems": 50,
  "includeDetails": true
}
```

### Example input: fast listing scan

```json
{
  "keywords": ["accounting"],
  "maxItems": 250,
  "includeDetails": false
}
```

### How to run

1. Open the actor on Apify.
2. Enter one or more Randstad keywords or start URLs.
3. Set `maxItems` to your desired volume.
4. Keep `includeDetails` enabled for rich descriptions.
5. Click **Start**.
6. Download the dataset as JSON, CSV, Excel, XML, or via API.

### Output example

```json
{
  "title": "Material Handler General Warehouse Associate",
  "company": "Randstad USA",
  "location": "Westbury, New York",
  "jobType": "TEMPORARY, FULL_TIME",
  "salaryText": "$17 - $20 / hour",
  "postedDate": "2026-06-10",
  "referenceNumber": "AB_4957441",
  "url": "https://www.randstadusa.com/jobs/.../"
}
```

### Tips for best results

Use broad keywords for market maps.

Use exact Randstad category URLs for repeatable dashboards.

Use `includeDetails: false` when you only need titles, locations, dates, and URLs.

Use `includeDetails: true` when descriptions and qualifications matter.

Increase `maxItems` gradually when building a new recurring workflow.

### Common workflows

#### Hiring trend monitor

Run daily for keywords like `warehouse`, `manufacturing`, or `accounting`.

Export counts by city, state, salary range, and posting date.

#### Competitive staffing intelligence

Track which roles Randstad is filling in a region.

Compare salary ranges and employment types over time.

#### Recruiting lead generation

Collect roles and geographies with active demand.

Route high-value openings to sales or sourcing teams.

#### Compensation research

Use normalized salary fields to monitor pay ranges by occupation.

Filter by hourly vs yearly units in your downstream system.

### Integrations

#### Dashboard and warehouse workflows

Send each dataset to Google Sheets for quick branch-level review, or load recurring runs into BigQuery, Snowflake, Databricks, or Postgres for trend analysis.

#### Alerting workflows

Use Apify webhooks to trigger Slack, Teams, email, or PagerDuty alerts when new Randstad jobs match a role, city, salary threshold, or employment type.

#### CRM and sales workflows

Route high-value postings into HubSpot, Salesforce, Clay, Airtable, or a custom CRM with fields such as title, city, salary range, job type, and apply URL.

#### Recruiting analytics workflows

Combine this dataset with your own applicant tracking system, job-board exports, or compensation data to compare Randstad demand against your internal pipeline.

#### AI and MCP workflows

Call the actor from Claude, Cursor, VS Code, or your own AI agent to answer questions such as "where are warehouse wages rising this week?" without manually exporting CSV files.

### 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('automation-lab/randstad-usa-jobs-scraper').call({
  keywords: ['warehouse'],
  maxItems: 100,
  includeDetails: true,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/randstad-usa-jobs-scraper').call(run_input={
    'keywords': ['warehouse'],
    'maxItems': 100,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~randstad-usa-jobs-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["warehouse"],"maxItems":100,"includeDetails":true}'
```

### MCP usage

Use the Apify MCP server to call this actor from Claude, Cursor, VS Code, and other MCP-compatible tools.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/randstad-usa-jobs-scraper`

#### Claude Code setup

```bash
claude mcp add apify --transport http "https://mcp.apify.com/?tools=automation-lab/randstad-usa-jobs-scraper"
```

Then ask Claude Code to run the actor with inputs such as `keywords`, `locations`, `maxItems`, and `includeDetails`.

#### Claude Desktop setup

Add this server to your Claude Desktop MCP configuration:

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

Restart Claude Desktop after saving the configuration, then choose the Apify tool when you want live Randstad USA job data.

#### Cursor setup

In Cursor, open MCP settings, add an HTTP MCP server, and use this URL:

```text
https://mcp.apify.com/?tools=automation-lab/randstad-usa-jobs-scraper
```

Use prompts that ask Cursor to fetch current Randstad jobs before editing dashboards, notebooks, or analysis scripts.

#### VS Code setup

In VS Code with an MCP-compatible extension, add a new HTTP server using the same Apify MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/randstad-usa-jobs-scraper
```

Store your Apify token according to the extension's instructions, then call the actor from your coding or analysis workspace.

Example prompts:

- "Scrape 100 Randstad USA warehouse jobs and summarize salary ranges by state."
- "Find current Randstad accounting jobs in Texas and export the dataset."
- "Monitor Randstad USA manufacturing roles and alert me about new high-paying postings."
- "Compare this week's Randstad manufacturing jobs with last week's dataset and flag new states."

### Data freshness

The actor reads live public Randstad pages during each run.

Results reflect what Randstad exposes at run time.

Old Randstad search URLs can return empty or unavailable pages.

The actor treats those as no-results instead of failing the whole run.

### Limitations

The actor only extracts public Randstad USA pages.

It does not log in, apply to jobs, or bypass access controls.

Some fields are optional because Randstad postings vary by job type.

Salary may be hourly or annual depending on the posting.

### Legality

This actor extracts publicly available job-posting information.

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

Do not use scraped data for unlawful discrimination, spam, or abusive automation.

### FAQ

#### Can I scrape Randstad USA jobs by keyword?

Yes. Add one or more `keywords` such as `warehouse`, `manufacturing`, or `accounting`.

#### Can I scrape an exact Randstad search URL?

Yes. Put the URL in `startUrls` and keep `keywords` empty if you only want that source.

### Troubleshooting

#### Why did I get zero results?

The keyword may have no current jobs, or Randstad may return a stale 410-like page. Try a broader keyword such as `warehouse`.

#### Why are some fields missing?

Randstad does not publish every field on every posting. Optional fields are omitted when unavailable.

#### How do I reduce cost?

Set a lower `maxItems` or disable detail extraction with `includeDetails: false`.

### Related scrapers

Explore other Automation Lab actors at:

- https://apify.com/automation-lab
- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/linkedin-jobs-scraper
- https://apify.com/automation-lab/indeed-scraper

### Support

If a Randstad page shape changes, open an Apify issue with the input you used and a sample run.

Include the start URL, keyword, and expected output so the extractor can be adjusted quickly.

### Changelog

Initial version extracts Randstad USA search results and detail-page fields with HTTP-only scraping.

# Actor input Schema

## `keywords` (type: `array`):

Optional Randstad job keywords. Each keyword is converted into a Randstad USA search URL, for example warehouse or accounting.

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

Optional city, state, or ZIP locations to search on Randstad USA.

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

Randstad USA job search, category, location, or detail URLs. Use this for exact pages such as https://www.randstadusa.com/jobs/q-warehouse/.

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

Maximum Randstad job postings to save across all searches.

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

Fetch each job detail page to extract full descriptions, salary, responsibilities, and validity dates. Disable for faster listing-only monitoring.

## Actor input object example

```json
{
  "keywords": [
    "warehouse"
  ],
  "locations": [],
  "startUrls": [
    {
      "url": "https://www.randstadusa.com/jobs/q-warehouse/"
    }
  ],
  "maxItems": 20,
  "includeDetails": true
}
```

# 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 = {
    "keywords": [
        "warehouse"
    ],
    "locations": [],
    "startUrls": [
        {
            "url": "https://www.randstadusa.com/jobs/q-warehouse/"
        }
    ],
    "maxItems": 20,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/randstad-usa-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 = {
    "keywords": ["warehouse"],
    "locations": [],
    "startUrls": [{ "url": "https://www.randstadusa.com/jobs/q-warehouse/" }],
    "maxItems": 20,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/randstad-usa-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 '{
  "keywords": [
    "warehouse"
  ],
  "locations": [],
  "startUrls": [
    {
      "url": "https://www.randstadusa.com/jobs/q-warehouse/"
    }
  ],
  "maxItems": 20,
  "includeDetails": true
}' |
apify call automation-lab/randstad-usa-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Randstad USA Jobs Scraper",
        "description": "Extract Randstad USA job postings with salaries, locations, descriptions, responsibilities, qualifications, and apply URLs from public pages.",
        "version": "0.1",
        "x-build-id": "ea3488VM8aJP9Dtut"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~randstad-usa-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-randstad-usa-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/automation-lab~randstad-usa-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-randstad-usa-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/automation-lab~randstad-usa-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-randstad-usa-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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Optional Randstad job keywords. Each keyword is converted into a Randstad USA search URL, for example warehouse or accounting.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Optional city, state, or ZIP locations to search on Randstad USA.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Randstad USA job search, category, location, or detail URLs. Use this for exact pages such as https://www.randstadusa.com/jobs/q-warehouse/.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum Randstad job postings to save across all searches.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Open job detail pages",
                        "type": "boolean",
                        "description": "Fetch each job detail page to extract full descriptions, salary, responsibilities, and validity dates. Disable for faster listing-only monitoring.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```