# iCIMS Jobs Scraper (`automation-lab/icims-jobs-scraper`) Actor

Extract public iCIMS employer jobs with full requisition details, locations, qualifications, visa and travel fields, descriptions, and direct apply URLs.

- **URL**: https://apify.com/automation-lab/icims-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 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/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

## iCIMS Jobs Scraper

Extract public jobs from iCIMS employer career portals into clean, integration-ready data.

**iCIMS Jobs Scraper** accepts a career portal, search page, or individual requisition URL and returns normalized job records with full descriptions, qualifications, location, visa sponsorship, travel requirements, and direct application links.

- 🔎 Discover every job exposed by a public iCIMS search page
- 📄 Fetch full requisition details instead of returning thin search cards
- 🏢 Process multiple employers in one run
- 🔁 Deduplicate jobs by iCIMS tenant and requisition ID
- 📤 Export to JSON, CSV, Excel, XML, RSS, or an API

Use it for repeatable hiring feeds without maintaining employer-specific HTML scripts.

### What does iCIMS Jobs Scraper do?

The Actor turns public iCIMS career pages into structured job data.

It follows search pagination, discovers requisition pages, extracts common iCIMS fields, and stores one job per dataset row. You can also submit a direct job URL when you only need one requisition.

The scraper is HTTP-first. It reads server-rendered iCIMS pages without launching a browser, which keeps runs fast and cost-efficient.

### Who is it for?

#### Job aggregators

Collect current vacancies from employers that use iCIMS and merge them into a searchable job index.

#### Recruiter intelligence teams

Track which departments, locations, and role families are expanding at target companies.

#### Labor-market analysts

Build recurring snapshots of openings by category, city, state, country, and requisition identity.

#### Sales and B2B research teams

Use hiring activity as an account signal for staffing, software, consulting, relocation, or benefits outreach.

#### Developers and data engineers

Feed normalized job records into a warehouse, webhook, automation, or internal search product.

### Why use this iCIMS job extractor?

- ✅ **Public inputs:** no iCIMS login or employer credentials are required for public portals.
- ✅ **Full records:** detail pages provide richer data than search cards alone.
- ✅ **Stable identity:** tenant plus requisition ID supports monitoring and deduplication.
- ✅ **Flexible URLs:** use tenant roots, search URLs with filters, or direct job pages.
- ✅ **Fail-loud safety:** invalid targets and total extraction failures do not silently produce successful empty runs.
- ✅ **Low overhead:** direct HTTP avoids browser startup and heavy page resources.

### What iCIMS job data can I extract?

| Field | Description |
|---|---|
| `title` | Public requisition title |
| `requisitionId` | Employer's iCIMS requisition identifier |
| `category` | Job category or function |
| `country` | Country shown by the employer |
| `state` | State or province |
| `city` | City or advertised site |
| `location` | Combined city, state, and country |
| `description` | Clean text from the full job description |
| `descriptionHtml` | Source HTML for formatting-aware workflows |
| `duties` | Duties, responsibilities, or overview section when labeled |
| `qualifications` | Qualifications or requirements section when labeled |
| `additionalInformation` | Additional information section when labeled |
| `visaSponsorship` | Employer's public visa sponsorship field |
| `travelRequirements` | Public travel requirement |
| `employer` | Employer override or tenant-derived name |
| `tenant` | iCIMS portal subdomain |
| `canonicalUrl` | Clean public requisition URL |
| `applyUrl` | Direct iCIMS application URL |
| `sourceUrl` | Exact URL fetched by the Actor |
| `scrapedAt` | UTC extraction timestamp |

Optional fields are omitted when an employer does not publish them.

### How to scrape iCIMS jobs

1. Open the Actor in Apify Console.
2. Add one or more public `https://*.icims.com` URLs.
3. Set **Maximum jobs** to the number of requisitions you need.
4. Keep **Fetch full job details** enabled.
5. Optionally enter an employer display name.
6. Click **Start**.
7. Open the dataset to preview, filter, or export the records.

A small first run with five jobs is enough to verify a new employer portal.

### Input

```json
{
  "startUrls": [
    {
      "url": "https://globalcareers-sas.icims.com/jobs/search?ss=1&in_iframe=1"
    }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "employerName": "SAS",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Input fields

| Parameter | Type | Required | Default | Purpose |
|---|---|---:|---:|---|
| `startUrls` | array | Yes | sample portal | Tenant roots, searches, or direct job URLs |
| `maxItems` | integer | No | 20 | Maximum unique requisitions to save |
| `includeDetails` | boolean | No | true | Required for normalized full-detail output |
| `employerName` | string | No | tenant | Stable employer display name |
| `proxyConfiguration` | object | No | direct | Optional Apify Proxy settings |

Search URL query parameters are preserved, so employer-provided keyword and location filters continue to work.

### Supported URL formats

The Actor accepts public HTTPS hosts ending in `.icims.com`.

```text
https://careers-example.icims.com
https://careers-example.icims.com/jobs/search
https://careers-example.icims.com/jobs/search?searchKeyword=engineer
https://careers-example.icims.com/jobs/12345/example-role/job
```

A tenant root is normalized to `/jobs/search?ss=1&in_iframe=1`. Non-iCIMS domains are rejected.

### Output example

```json
{
  "title": "Sr Finance Business Partner (Individual Contributor level)",
  "requisitionId": "2026-42328",
  "category": "Information Technology",
  "country": "United States",
  "state": "North Carolina",
  "city": "Cary HQ",
  "location": "Cary HQ, North Carolina, United States",
  "description": "Summary of Duties: Works as an Individual Contributor...",
  "duties": "Works as an Individual Contributor and reports to a Director...",
  "qualifications": "Position requires a Bachelor's degree...",
  "visaSponsorship": "No",
  "travelRequirements": "None",
  "employer": "SAS",
  "tenant": "careers-sas",
  "canonicalUrl": "https://careers-sas.icims.com/jobs/42328/example/job?hub=9",
  "applyUrl": "https://careers-sas.icims.com/jobs/42328/example/job?mode=apply&apply=yes...",
  "sourceUrl": "https://careers-sas.icims.com/jobs/42328/example/job?hub=9&in_iframe=1",
  "scrapedAt": "2026-07-18T00:00:00.000Z"
}
```

The default dataset contains one entity type: job requisitions.

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

This Actor uses pay-per-event pricing. A **$0.005 start charge** covers run setup, then each saved job is charged at the rate for your Apify plan.

| Apify tier | Price per saved job |
|---|---:|
| FREE | $0.000095582 |
| BRONZE | $0.000083115 |
| SILVER | $0.00006483 |
| GOLD | $0.000049869 |
| PLATINUM | $0.000033246 |
| DIAMOND | $0.000023272 |

Your exact estimate appears in Apify Console before a run. Control spend with `maxItems`; start with five jobs when testing a portal, then scale after reviewing the output.

The free Apify plan can be used for small evaluations within the credits available on your account.

### Pagination and deduplication

Search pages expose paginator links. The Actor follows the next-page link only when more jobs are needed.

Each output key combines:

```text
<iCIMS tenant>:<requisition ID>
```

This prevents duplicate rows when multiple submitted search pages point to the same requisition during one run.

For monitoring across runs, use the same key in your database or automation.

### Tips for reliable extraction

- 🎯 Submit the employer's iCIMS search page rather than a marketing-site wrapper.
- 🧪 Test a new portal with `maxItems: 5` before a large collection.
- 🏷️ Set `employerName` when you want a polished company name in every row.
- 🔗 Preserve employer filter parameters in your submitted search URL.
- 🌐 Use a proxy only if a portal restricts your current region or network.
- 🕐 Schedule recurring runs at a frequency appropriate for the employer's hiring activity.

### Integrations

#### Google Sheets and Excel

Export the dataset to CSV or XLSX for recruiter research, reporting, or manual review.

#### Webhooks and automation

Trigger Make, Zapier, n8n, or a custom webhook when a scheduled run finishes. Compare requisition keys to identify newly opened or removed jobs.

#### Data warehouses

Load JSON records into BigQuery, Snowflake, PostgreSQL, or object storage. Use `scrapedAt` for snapshot partitions.

#### Recruiting and sales systems

Map employer, title, category, and location into an ATS, CRM, lead-scoring model, or account intelligence workflow.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/icims-jobs-scraper').call({
    startUrls: [{ url: 'https://globalcareers-sas.icims.com/jobs/search' }],
    maxItems: 20,
    includeDetails: true,
    employerName: 'SAS',
});

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

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/icims-jobs-scraper').call(run_input={
    'startUrls': [{'url': 'https://globalcareers-sas.icims.com/jobs/search'}],
    'maxItems': 20,
    'includeDetails': True,
    'employerName': 'SAS',
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~icims-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://globalcareers-sas.icims.com/jobs/search"}],
    "maxItems": 20,
    "includeDetails": true,
    "employerName": "SAS"
  }'
```

Fetch results from the run's default dataset after it succeeds.

### Use iCIMS Jobs Scraper with MCP

Connect the Actor to Claude Code:

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

For Claude Desktop, Cursor, or VS Code, add this MCP server configuration:

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

Example prompts:

- “Extract the first 25 jobs from this iCIMS employer portal.”
- “Return titles, requisition IDs, locations, and apply URLs as a table.”
- “Compare this week's requisition IDs with last week's dataset.”

### Scheduling an iCIMS job monitor

Create an Apify schedule with the same employer URLs and a stable dataset destination or downstream webhook.

A typical monitor:

1. runs daily or weekly;
2. stores the latest job rows;
3. compares tenant and requisition ID against the previous snapshot;
4. sends newly discovered jobs to Slack, email, a CRM, or a warehouse.

Choose a cadence that respects the target site and your business need.

### Error handling

The run fails with a clear message when:

- a URL is invalid or outside public iCIMS domains;
- a page cannot be fetched after bounded retries;
- a search page exposes no iCIMS job links;
- a detail page lacks required job identity fields;
- the complete run would otherwise emit zero jobs.

A single temporary request is retried, but the Actor does not hide total extraction failures behind an empty successful dataset.

### Limitations

- Employer-specific iCIMS themes can rename or omit optional labels.
- The Actor extracts public postings only; candidate dashboards and login-only jobs are not supported.
- `includeDetails` must remain enabled in the current release.
- Employers may move applications to another system after an iCIMS redirect.
- Description section splitting depends on visible labels such as “Qualifications:” or “Requirements:”. The full description remains available even when sections cannot be split.

### Is scraping iCIMS jobs legal?

The Actor extracts information published on public employer career pages. Public availability does not remove your responsibilities.

You should:

- follow applicable laws and contractual obligations;
- respect employer terms and reasonable request rates;
- avoid collecting candidate, applicant, or login-protected personal data;
- use job data for a legitimate purpose;
- apply retention and privacy controls appropriate to your jurisdiction.

This documentation is not legal advice.

### FAQ

#### Does this Actor need an iCIMS account?

No. It is designed for publicly visible employer career portals and requisition pages.

#### Can I scrape several employers at once?

Yes. Add multiple iCIMS URLs to `startUrls`. `maxItems` applies to the combined run.

#### Can I scrape one known job URL?

Yes. Submit the direct `/jobs/{id}/{slug}/job` URL and set `maxItems` to `1`.

#### Why did my portal return no jobs?

Confirm that the URL opens an iCIMS `/jobs/search` page rather than an employer marketing wrapper. Try the URL with `?ss=1&in_iframe=1`, or enable an Apify proxy if the employer restricts your network.

#### Why is an optional output field missing?

Employers control which iCIMS fields they publish. Missing optional values are omitted rather than represented by misleading placeholders.

#### How do I detect new jobs?

Schedule repeated runs and compare the combination of `tenant` and `requisitionId` with your previous dataset.

### Related job scrapers

Build a broader hiring-data workflow with other Automation Lab Actors:

- [Greenhouse Jobs Scraper](https://apify.com/automation-lab/greenhouse-jobs-scraper)
- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper)
- [Indeed Scraper](https://apify.com/automation-lab/indeed-scraper)
- [Glassdoor Jobs Scraper](https://apify.com/automation-lab/glassdoor-jobs-scraper)

Use the source-specific Actor that matches each employer's career system, then normalize the resulting datasets in your downstream pipeline.

### Support

If a public iCIMS portal uses a layout that is not recognized, open an issue from the Actor page and include:

- the public portal or requisition URL;
- the input used;
- the run ID;
- which fields or records you expected.

Do not include private applicant credentials or personal candidate information.

# Actor input Schema

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

Add public iCIMS tenant, search, or job-detail URLs. Tenant roots are automatically converted to /jobs/search.

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

Stop after saving this many unique requisitions across all portals.

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

Fetch each requisition page to include descriptions, qualifications, visa, travel, and apply links.

## `employerName` (type: `string`):

Optional display name to use instead of the tenant subdomain.

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

Optional Apify Proxy settings for portals that restrict your network location.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://globalcareers-sas.icims.com/jobs/search?ss=1&in_iframe=1"
    }
  ],
  "maxItems": 5,
  "includeDetails": true,
  "employerName": "SAS",
  "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 = {
    "startUrls": [
        {
            "url": "https://globalcareers-sas.icims.com/jobs/search?ss=1&in_iframe=1"
        }
    ],
    "maxItems": 5,
    "includeDetails": true,
    "employerName": "SAS",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/icims-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 = {
    "startUrls": [{ "url": "https://globalcareers-sas.icims.com/jobs/search?ss=1&in_iframe=1" }],
    "maxItems": 5,
    "includeDetails": True,
    "employerName": "SAS",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/icims-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 '{
  "startUrls": [
    {
      "url": "https://globalcareers-sas.icims.com/jobs/search?ss=1&in_iframe=1"
    }
  ],
  "maxItems": 5,
  "includeDetails": true,
  "employerName": "SAS",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/icims-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "iCIMS Jobs Scraper",
        "description": "Extract public iCIMS employer jobs with full requisition details, locations, qualifications, visa and travel fields, descriptions, and direct apply URLs.",
        "version": "0.1",
        "x-build-id": "0hs2AvCV8DI06cIWT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~icims-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-icims-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~icims-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-icims-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~icims-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-icims-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🏢 iCIMS career portal or job URLs",
                        "type": "array",
                        "description": "Add public iCIMS tenant, search, or job-detail URLs. Tenant roots are automatically converted to /jobs/search.",
                        "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": "Stop after saving this many unique requisitions across all portals.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Fetch full job details",
                        "type": "boolean",
                        "description": "Fetch each requisition page to include descriptions, qualifications, visa, travel, and apply links.",
                        "default": true
                    },
                    "employerName": {
                        "title": "Employer name override",
                        "type": "string",
                        "description": "Optional display name to use instead of the tenant subdomain."
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings for portals that restrict your network location."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```