# Jora Scraper (`solidcode/jora-scraper`) Actor

\[💰 $1.0 / 1K] Extract job listings from Jora across 6 countries — title, company, salary, location, work type, posting date, and full descriptions. Search by keyword and location or paste Jora search URLs.

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

## Pricing

from $1.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are 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

## Jora Job Scraper

Pull job listings from Jora across six Asia-Pacific markets in a single run — title, company, location, salary, work type, posting date, summary, and the full description on demand. Search by keyword and location, or paste any Jora search URL to clone a saved search exactly. Built for recruiters, labor-market researchers, and relocation and talent-mapping teams who need structured APAC job data without collecting it by hand.

### Why This Scraper?

- **6 APAC job markets in one actor** — Australia, New Zealand, Singapore, Hong Kong, Malaysia, and Indonesia, each as a simple country dropdown. No separate run, no rebuilt URL per market.
- **Full job descriptions on demand** — flip `includeJobDetails` on to capture each posting's complete description text, not just the search-result snippet.
- **5 date-posted windows + 5 employment-type filters** — narrow to the last 24 hours, 7, 14, or 30 days, and to Full time, Part time, Contract, Permanent, or Casual / Temporary — all applied by Jora's own search so they never waste result credits.
- **ISO-normalized posting dates** — every job carries both Jora's human text ("Posted 15h ago") and a clean `postedAt` date (`2026-06-02`) you can sort and filter on directly.
- **Salary captured when advertised** — annual and monthly pay strings are parsed out of each card and kept in a dedicated `salary` field, in the country's local currency, never mixed into work type.
- **Paste any Jora search URL** — copy a refined search straight from your browser and the actor clones it verbatim, including every filter you set on the site.
- **Up to ~1,000 listings per search** — smooth pagination to Jora's practical depth, with cross-search de-duplication so the same job never lands twice.
- **Minimum-salary, radius, and quick-apply filters** — set an annual salary floor, widen the search by kilometres from a location, or keep only one-click apply jobs.
- **One flat row per job** — title, company, location, salary, work type, dates, summary, and a direct apply link, ready for a spreadsheet with no reshaping.

### Use Cases

**Recruitment & Talent Sourcing**
- Build live candidate-demand lists for a role across Sydney, Auckland, and Singapore at once
- Track quick-apply roles to spot openings candidates can reach in one click
- Monitor a single keyword (e.g. "registered nurse") across all six markets daily
- Pull direct apply links for every matching posting into your ATS

**Labor-Market & Economic Research**
- Measure hiring volume by keyword and region across the Asia-Pacific
- Compare full-time vs. part-time vs. contract mix between countries
- Track week-over-week posting velocity using the `postedAt` date
- Map which cities a role concentrates in by location frequency

**Salary Benchmarking**
- Aggregate advertised salaries for a job title by country and currency
- Compare annual pay bands between Australia and New Zealand for the same role
- Set a `minSalary` floor to isolate senior or premium postings
- Build pay-range reports for relocation and compensation teams

**Competitor Hiring Intelligence**
- Watch a named company's open roles across every Jora market
- Detect expansion signals from a surge in a competitor's postings
- Capture full descriptions to read a rival's required skills and stack

**Relocation & Talent-Mapping Services**
- Surface roles within a radius of a target city for relocating clients
- Filter to the last 7 days to keep candidate shortlists fresh
- Combine country and keyword to scope a market-entry feasibility study

### Getting Started

#### Simple Keyword Search

One keyword, one country, capped at 50 results:

```json
{
    "searchKeywords": ["software engineer"],
    "country": "au",
    "maxItems": 50
}
````

#### Filtered Search (Location + Recency + Type)

Recent full-time roles near a city, newest first:

```json
{
    "searchKeywords": ["registered nurse"],
    "location": "Sydney NSW",
    "country": "au",
    "datePosted": "7d",
    "jobType": "3",
    "sortBy": "date",
    "maxItems": 200
}
```

#### Paste a Jora Search URL

Copy any search from your browser — every on-site filter is preserved:

```json
{
    "startUrls": [
        "https://sg.jora.com/j?q=data+analyst&l=Singapore"
    ],
    "maxItems": 100
}
```

#### Full-Featured Example

Salary floor, radius, quick-apply only, with full descriptions:

```json
{
    "searchKeywords": ["project manager"],
    "location": "Auckland",
    "country": "nz",
    "datePosted": "30d",
    "jobType": "6",
    "minSalary": 90000,
    "radius": 25,
    "quickApply": true,
    "sortBy": "date",
    "includeJobDetails": true,
    "maxItems": 500
}
```

### Input Reference

#### What to Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchKeywords` | string\[] | `["software engineer"]` | Job titles or keywords. Each keyword runs as its own search. Leave empty if you are pasting search URLs. |
| `location` | string | `""` | City, region, or postcode to search within (e.g. "Sydney NSW", "Auckland"). Leave empty to search the whole country. |
| `country` | select | `Australia` | Which Jora market to search: Australia, New Zealand, Singapore, Hong Kong, Malaysia, or Indonesia. |
| `startUrls` | string\[] | `[]` | Paste full Jora search URLs to clone a search exactly. Overrides the keyword, location, country, and filter fields. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `datePosted` | select | `Any time` | Only include jobs posted within Last 24 hours, 7 days, 14 days, or 30 days. |
| `jobType` | select | `Any type` | Employment type: Full time, Part time, Contract, Permanent, or Casual / Temporary. |
| `sortBy` | select | `Most relevant` | Order by relevance to your keywords, or by newest posting date first. |
| `minSalary` | integer | null | Only include jobs advertising at least this annual salary, in local currency. |
| `radius` | integer | null | Expand the search to jobs within this many kilometres of the location. |
| `quickApply` | boolean | `false` | Keep only jobs you can apply to directly on Jora, without an external site. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxItems` | integer | `100` | Maximum job listings to collect across all searches. Set to `0` for every available result (Jora caps a single search at roughly 1,000). |
| `includeJobDetails` | boolean | `false` | Open each posting to capture the full description text. Slower — one extra page per job — but gives the complete listing. |

### Output

One flat row per job. Here's a representative result with full details enabled:

```json
{
    "title": "Software Engineer",
    "company": "Atlassian",
    "location": "Sydney NSW",
    "salary": "$120,000 - $150,000 a year",
    "workType": "Full time",
    "postedAt": "2026-06-01",
    "postedAtText": "Posted 1d ago",
    "summary": "Join our platform team building developer tools used by millions...",
    "description": "About the role\nWe are looking for a Software Engineer to join...",
    "country": "au",
    "searchKeyword": "software engineer",
    "jobId": "a1b2c3d4e5",
    "url": "https://au.jora.com/job/Software-Engineer-a1b2c3d4e5"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Job title as listed |
| `company` | string | Hiring company name |
| `location` | string | City or region of the role |
| `salary` | string | Advertised pay in local currency — only when the listing states one |
| `workType` | string | Employment type (Full time, Part time, Contract, etc.) |
| `url` | string | Direct link to the job on Jora |

#### Job Details

| Field | Type | Description |
|-------|------|-------------|
| `postedAt` | string | Normalized posting date (`YYYY-MM-DD`) for sorting and filtering |
| `postedAtText` | string | Jora's original posting text (e.g. "Posted 15h ago") |
| `summary` | string | Short snippet from the search result card |
| `description` | string | Full posting description — only when `includeJobDetails` is on |

#### Metadata

| Field | Type | Description |
|-------|------|-------------|
| `country` | string | Jora market code the job came from (`au`, `nz`, `sg`, `hk`, `my`, `id`) |
| `searchKeyword` | string | The keyword (or URL) that produced this row |
| `jobId` | string | Jora's unique identifier for the listing |

### Tips for Best Results

- **Start small** — set `maxItems` to 25–50 on your first run to confirm the data matches your needs, then scale up.
- **Use `startUrls` to replicate a refined search** — set every filter on Jora's site, copy the URL, and the actor reproduces that exact search, including filters not exposed as inputs here.
- **Turn on `includeJobDetails` only when you need full text** — it adds one extra page fetch per job, so leave it off for fast, high-volume runs that only need the card summary.
- **Filters are free** — `datePosted`, `jobType`, `sortBy`, `minSalary`, `radius`, and `quickApply` are applied by Jora's own search, so they shrink the result set rather than spending result credits on jobs you'll discard.
- **Sort by newest for monitoring** — set `sortBy` to "Newest first" and `datePosted` to "Last 24 hours" to pull only fresh postings on a daily schedule.
- **One keyword per market gives the cleanest reports** — run a single keyword against one country at a time when you want tidy per-market salary or volume tables.
- **Salary appears only when advertised** — many APAC listings omit pay, so expect the `salary` field to be present on a subset of rows; pair with `minSalary` to keep only postings that state a figure.

### Pricing

**From $1.00 per 1,000 results** — a flat pay-per-result rate that undercuts comparable Jora extractors. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.12 | $0.115 | $0.105 | $0.10 |
| 1,000 | $1.20 | $1.15 | $1.05 | $1.00 |
| 10,000 | $12.00 | $11.50 | $10.50 | $10.00 |
| 100,000 | $120.00 | $115.00 | $105.00 | $100.00 |

A "result" is any job row in the output dataset. Platform fees from your Apify plan are additional.

### Integrations

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

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

### Legal & Ethical Use

This actor is designed for legitimate recruitment, labor-market research, salary benchmarking, and hiring intelligence. Users are responsible for complying with applicable laws and Jora's Terms of Service. Do not use extracted data for spam, harassment, discriminatory hiring, or any illegal purpose. Be mindful of employment and personal-data regulations in each market you collect from. </content> </invoke>

# Actor input Schema

## `searchKeywords` (type: `array`):

Job titles or keywords to search for, such as 'software engineer', 'nurse', or 'warehouse'. Each keyword runs as its own search. Leave empty if you are pasting search URLs below.

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

City, region, or postcode to search within, such as 'Sydney NSW' or 'Auckland'. Leave empty to search the whole country.

## `country` (type: `string`):

Which Jora country site to search. Each keyword search runs against this country's listings.

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

Paste full Jora search result URLs (for example https://au.jora.com/j?q=developer\&l=Sydney). Use this when you want to copy a search straight from your browser. Overrides the keyword, location, country, and filter fields above. Each pasted search is crawled from page 1 through all result pages, so any page number in the URL is ignored.

## `datePosted` (type: `string`):

Only include jobs posted within this time window.

## `jobType` (type: `string`):

Only include jobs of this employment type.

## `sortBy` (type: `string`):

Order results by relevance to your keywords, or by newest posting date first.

## `minSalary` (type: `integer`):

Only include jobs advertising at least this annual salary, in the country's local currency. Leave empty for no salary filter.

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

Expand the search to include jobs within this many kilometres of the location. Leave empty for the default radius. Only applies when a location is set.

## `quickApply` (type: `boolean`):

Only include jobs you can apply to directly on Jora, without leaving for an external site.

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

Maximum number of job listings to collect across all searches. Set to 0 to collect every available result (Jora typically caps a single search at around 1,000 listings).

## `includeJobDetails` (type: `boolean`):

Open each job posting to collect the full description text. This is slower and visits one extra page per job, but gives you the complete listing instead of just the search-result summary.

## Actor input object example

```json
{
  "searchKeywords": [
    "software engineer"
  ],
  "country": "au",
  "startUrls": [],
  "datePosted": "any",
  "jobType": "any",
  "sortBy": "relevance",
  "quickApply": false,
  "maxItems": 100,
  "includeJobDetails": false
}
```

# Actor output Schema

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

Table of jobs with key fields like title, company, location, salary, and link.

## `details` (type: `string`):

Full per-job rows including description, work type, posting date, and source search.

# 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 = {
    "searchKeywords": [
        "software engineer"
    ],
    "location": "",
    "country": "au",
    "startUrls": [],
    "datePosted": "any",
    "jobType": "any",
    "sortBy": "relevance",
    "quickApply": false,
    "maxItems": 100,
    "includeJobDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/jora-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 = {
    "searchKeywords": ["software engineer"],
    "location": "",
    "country": "au",
    "startUrls": [],
    "datePosted": "any",
    "jobType": "any",
    "sortBy": "relevance",
    "quickApply": False,
    "maxItems": 100,
    "includeJobDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/jora-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 '{
  "searchKeywords": [
    "software engineer"
  ],
  "location": "",
  "country": "au",
  "startUrls": [],
  "datePosted": "any",
  "jobType": "any",
  "sortBy": "relevance",
  "quickApply": false,
  "maxItems": 100,
  "includeJobDetails": false
}' |
apify call solidcode/jora-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jora Scraper",
        "description": "[💰 $1.0 / 1K] Extract job listings from Jora across 6 countries — title, company, salary, location, work type, posting date, and full descriptions. Search by keyword and location or paste Jora search URLs.",
        "version": "1.0",
        "x-build-id": "DqZ99BRRcczt6Kwg4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~jora-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-jora-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~jora-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-jora-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~jora-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-jora-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": {
                    "searchKeywords": {
                        "title": "Job Keywords",
                        "type": "array",
                        "description": "Job titles or keywords to search for, such as 'software engineer', 'nurse', or 'warehouse'. Each keyword runs as its own search. Leave empty if you are pasting search URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, or postcode to search within, such as 'Sydney NSW' or 'Auckland'. Leave empty to search the whole country."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "au",
                            "nz",
                            "sg",
                            "hk",
                            "my",
                            "id"
                        ],
                        "type": "string",
                        "description": "Which Jora country site to search. Each keyword search runs against this country's listings.",
                        "default": "au"
                    },
                    "startUrls": {
                        "title": "Jora Search URLs",
                        "type": "array",
                        "description": "Paste full Jora search result URLs (for example https://au.jora.com/j?q=developer&l=Sydney). Use this when you want to copy a search straight from your browser. Overrides the keyword, location, country, and filter fields above. Each pasted search is crawled from page 1 through all result pages, so any page number in the URL is ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "datePosted": {
                        "title": "Date Posted",
                        "enum": [
                            "any",
                            "24h",
                            "7d",
                            "14d",
                            "30d"
                        ],
                        "type": "string",
                        "description": "Only include jobs posted within this time window.",
                        "default": "any"
                    },
                    "jobType": {
                        "title": "Employment Type",
                        "enum": [
                            "any",
                            "3",
                            "1",
                            "4",
                            "6",
                            "2"
                        ],
                        "type": "string",
                        "description": "Only include jobs of this employment type.",
                        "default": "any"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Order results by relevance to your keywords, or by newest posting date first.",
                        "default": "relevance"
                    },
                    "minSalary": {
                        "title": "Minimum Salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include jobs advertising at least this annual salary, in the country's local currency. Leave empty for no salary filter."
                    },
                    "radius": {
                        "title": "Search Radius (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Expand the search to include jobs within this many kilometres of the location. Leave empty for the default radius. Only applies when a location is set."
                    },
                    "quickApply": {
                        "title": "Quick Apply Only",
                        "type": "boolean",
                        "description": "Only include jobs you can apply to directly on Jora, without leaving for an external site.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum Jobs",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of job listings to collect across all searches. Set to 0 to collect every available result (Jora typically caps a single search at around 1,000 listings).",
                        "default": 100
                    },
                    "includeJobDetails": {
                        "title": "Fetch Full Job Descriptions",
                        "type": "boolean",
                        "description": "Open each job posting to collect the full description text. This is slower and visits one extra page per job, but gives you the complete listing instead of just the search-result summary.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
