# Zoho Recruit Jobs Scraper (`automation-lab/zoho-recruit-jobs-scraper`) Actor

Extract normalized public openings from employer career sites hosted on Zoho Recruit, including IDs, titles, locations, dates, full descriptions, and canonical URLs.

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

## Pricing

from $0.08 / 1,000 job extracteds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Zoho Recruit Jobs Scraper

Export public job openings from employer career sites hosted on Zoho Recruit.
Provide career-page URLs or tenant slugs and receive one normalized dataset row per current public opening, including the employer, stable job ID, title, location, industry, employment type, experience, opening date, full description, and canonical detail URL.

The Actor uses the structured job data embedded in public Zoho Recruit pages.
It does not require a Zoho account, API key, browser, or proxy.

### What does Zoho Recruit Jobs Scraper do?

Zoho Recruit Jobs Scraper turns public `*.zohorecruit.com/jobs/Careers` pages into integration-ready records.
It can:

- process one or many employer tenants in a run;
- accept full listing or job-detail URLs;
- accept concise tenant subdomains such as `accountingbaba`;
- normalize ATS-specific field names into stable output;
- include the full public job description without extra detail requests;
- deduplicate jobs by tenant and stable Zoho job ID;
- stop at a global `maxItems` limit;
- generate canonical public job-detail links.

Only records marked public by the source are emitted.
A valid career page with no current openings produces an empty dataset.
A page that no longer has the expected Zoho data structure fails clearly instead of returning a misleading empty result.

### Who is it for?

#### Job aggregators

Build or refresh a feed of openings from employers that use Zoho Recruit.
Stable IDs make repeated polling and change detection straightforward.

#### Recruiters and staffing teams

Monitor client or competitor career pages without copying listings manually.
Export titles, locations, experience requirements, and descriptions to a spreadsheet or CRM.

#### Staffing-data vendors

Ingest normalized source records into downstream enrichment, classification, and matching pipelines.

#### Labor-market analysts

Track hiring activity by employer, location, industry, job type, or opening date.

#### Automation developers

Trigger the Actor from an API, schedule, webhook, Zapier, Make, n8n, or an Apify integration.

### Why use this Actor?

- **Source-specific:** designed for public Zoho Recruit career sites rather than arbitrary web pages.
- **Low overhead:** direct HTTP extraction; no browser or proxy traffic.
- **Complete useful records:** descriptions are already embedded on the listing page.
- **Stable deduplication:** every row contains the tenant and Zoho job ID.
- **Multiple input styles:** full URLs and tenant slugs can be combined.
- **Fail-closed parsing:** unexpected templates are reported as errors.
- **Integration-ready:** typed fields, a dataset view, and canonical source links are included.

### What data can you extract?

| Field | Type | Meaning |
|---|---|---|
| `jobId` | string | Stable Zoho Recruit job-opening ID |
| `tenant` | string | Employer's Zoho Recruit subdomain |
| `employer` | string | Public career-site employer name |
| `title` | string | Published job title |
| `city` | string or null | City supplied by the employer |
| `state` | string or null | State or region supplied by the employer |
| `country` | string or null | Country supplied by the employer |
| `location` | string or null | Combined city, state, and country |
| `industry` | string or null | Public industry classification |
| `jobType` | string or null | Employment type, such as Full time |
| `experience` | string or null | Public experience range |
| `openingDate` | string or null | Date the opening was created or opened |
| `description` | string or null | Full public job description |
| `sourceUrl` | URL | Canonical public job-detail URL |
| `careerPageUrl` | URL | Normalized tenant career-page URL |
| `scrapedAt` | ISO date-time | Time the record was extracted |

Optional fields are `null` when an employer does not publish them.

### How to scrape Zoho Recruit jobs

1. Open the Actor in Apify Console.
2. Add one or more public Zoho Recruit career URLs, tenant slugs, or both.
3. Set `maxItems` to the maximum total jobs you need.
4. Click **Start**.
5. Open the **Dataset** tab to preview or export JSON, CSV, Excel, XML, or RSS.
6. For recurring monitoring, create an Apify schedule and compare stable `tenant + jobId` keys with a prior run.

A small working input is:

```json
{
  "startUrls": [
    { "url": "https://accountingbaba.zohorecruit.com/jobs/Careers" }
  ],
  "maxItems": 25
}
```

### Input parameters

#### `startUrls`

Optional array of request-list sources.
Each URL must:

- use HTTPS;
- use a `*.zohorecruit.com` hostname;
- contain `/jobs/Careers`.

Both listing URLs and individual job-detail URLs are accepted.
They are normalized to the tenant listing page so all public openings can be extracted consistently.

#### `tenantSlugs`

Optional array of Zoho Recruit subdomains.
For example, `accountingbaba` becomes:

```text
https://accountingbaba.zohorecruit.com/jobs/Careers
```

Slugs may contain letters, digits, and internal hyphens.

#### `maxItems`

Optional integer from 1 to 10,000.
The default is 100.
The limit applies across all input tenants, not separately to each tenant.
Duplicate inputs do not consume the limit twice.

At least one `startUrls` or `tenantSlugs` value is required.

### Output example

This example is shortened only in the `description` field; the real dataset contains the complete public text.

```json
{
  "jobId": "569188000022262139",
  "tenant": "accountingbaba",
  "employer": "Accounting Baba",
  "title": "Research Analyst",
  "city": "Surat City",
  "state": "Gujarat",
  "country": "India",
  "location": "Surat City, Gujarat, India",
  "industry": "Consulting",
  "jobType": "Full time",
  "experience": "1-3 Years",
  "openingDate": "2026-07-15",
  "description": "Job Title: Research Analyst Location: New City Light, Surat ...",
  "sourceUrl": "https://accountingbaba.zohorecruit.com/jobs/Careers/569188000022262139/Research-Analyst",
  "careerPageUrl": "https://accountingbaba.zohorecruit.com/jobs/Careers",
  "scrapedAt": "2026-07-26T05:30:00.000Z"
}
```

### How much does it cost to scrape Zoho Recruit jobs?

The Actor uses pay-per-event pricing.
You pay only for dataset items produced; empty, rejected, failed, and duplicate records are not charged as items.
There is no separate start charge.

The base FREE-tier price is **$0.00015274 per job**, with lower per-item prices on higher Apify tiers.
At the base price:

- 25 jobs cost about **$0.00382**;
- 100 jobs cost about **$0.01527**;
- 1,000 jobs cost about **$0.15274**.

Apify platform plan allowances and higher-tier discounts can change the amount charged to your account.
Check the live pricing panel before a large run.

### Practical workflows

#### Create a recurring new-jobs monitor

Run the same tenant list daily.
Use `tenant + jobId` as the stable key and notify your team only when a key was not present in the previous dataset.

#### Build a multi-employer job feed

Pass many tenant slugs and set a global limit.
Export the default dataset as JSON or CSV for a job board, warehouse, or search index.

#### Enrich recruiting records

Send `title`, `description`, and `location` to a classifier for occupation codes, seniority, skills, remote-work signals, or salary mentions.
Keep `sourceUrl` for traceability.

#### Track employer hiring activity

Aggregate records by tenant, opening date, industry, or location.
Repeated runs can reveal hiring velocity and changes in active roles.

### Tips for reliable runs

- Prefer tenant listing URLs over copied redirect URLs.
- Keep tenant slugs exactly as they appear before `.zohorecruit.com`.
- Use a small `maxItems` while testing a new tenant.
- Treat `jobId` as a string; Zoho IDs can exceed safe JavaScript integer precision.
- Schedule at a frequency appropriate for the employer's update cadence.
- Store previous datasets externally if you need long-term history or change detection.
- Do not add an Apify proxy: the Actor intentionally uses direct public requests.

### Limits and expected failure behavior

- The Actor supports public career sites hosted on `*.zohorecruit.com` with the standard `/jobs/Careers` route.
- Private recruiter data, candidate records, applications, and logged-in portals are out of scope.
- Employers control which fields are present, so optional fields can be null.
- Results reflect the page at extraction time; the Actor does not create a historical snapshot automatically.
- A tenant can have zero current public jobs.
- Zoho or an employer can change the page template.
- A missing embedded job dataset is treated as an upstream/template error.
- Transient timeouts, rate limits, and server errors receive bounded retries.
- Invalid hosts and malformed tenant slugs fail before network extraction.

### Use the Apify API with cURL

Replace `YOUR_APIFY_TOKEN` with your token:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~zoho-recruit-jobs-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "tenantSlugs": ["accountingbaba", "advice"],
    "maxItems": 100
  }'
```

To wait for completion and receive dataset items directly:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~zoho-recruit-jobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"tenantSlugs":["accountingbaba"],"maxItems":25}'
```

### Use the Apify API with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/zoho-recruit-jobs-scraper').call({
    tenantSlugs: ['accountingbaba', 'advice'],
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Install the client with `npm install apify-client`.

### Use the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/zoho-recruit-jobs-scraper').call(run_input={
    'tenantSlugs': ['accountingbaba', 'advice'],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Install the client with `pip install apify-client`.

### Use Zoho Recruit Jobs Scraper with MCP

#### Claude Code setup

Add the Actor to Claude Code:

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

#### Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, and VS Code can use this equivalent MCP JSON configuration:

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

Example prompts:

- “Run Zoho Recruit Jobs Scraper for the accountingbaba tenant and return the first 20 jobs.”
- “Collect jobs from these three Zoho Recruit tenants and group the result by country.”
- “Find newly observed job IDs by comparing today’s result with yesterday’s dataset.”

### Integrations

Use the dataset with:

- Google Sheets or Excel for recruiting research;
- webhooks for new-run notifications;
- Make, Zapier, or n8n for workflow automation;
- Amazon S3, Google Drive, or a database export;
- Python, JavaScript, or BI tools through the Apify API;
- LLM and classification pipelines for skills or role enrichment.

The default dataset is the primary backward-compatible output.

### Responsible and legal use

This Actor extracts information that employers publish on public career pages.
Public availability does not remove your responsibilities.

- Follow applicable laws, website terms, and contractual obligations.
- Collect only data needed for a legitimate purpose.
- Do not use job data for discrimination, harassment, or deceptive outreach.
- Respect deletion and correction requests in downstream systems.
- Avoid republishing copyrighted descriptions when a link or short excerpt is sufficient.
- Review privacy and employment rules that apply in your jurisdiction.

The user is responsible for deciding whether a specific use is lawful.

### Troubleshooting

#### The run says no input was provided

Add at least one valid `startUrls` entry or `tenantSlugs` value.
The two fields are optional individually but one is required at runtime.

#### A start URL is rejected

Confirm it uses HTTPS, has a `*.zohorecruit.com` host, and includes `/jobs/Careers`.
Custom employer domains that redirect elsewhere are not accepted directly; use the resulting Zoho Recruit tenant URL.

#### A tenant returns zero rows

Open its public career page and confirm it currently displays openings.
A standard valid page with no published jobs legitimately returns zero items.

#### The parser reports a missing embedded dataset

The URL may not be a standard Zoho Recruit career page, the tenant may have been removed, or Zoho may have changed the template.
Check the URL in a browser and include the run ID when reporting a reproducible template issue.

#### The run timed out or received an upstream error

Retry later after confirming the tenant is reachable.
The Actor already retries transient 408, 429, and selected 5xx responses, so repeated failures usually indicate an upstream outage or changed page.

### Related Automation Lab actors

For other ATS-specific public job extraction workflows, consider:

- [Greenhouse Jobs Scraper](https://apify.com/automation-lab/greenhouse-jobs-scraper)
- [Workday Jobs Scraper](https://apify.com/automation-lab/workday-jobs-scraper)
- [Recruitee Jobs Scraper](https://apify.com/automation-lab/recruitee-jobs-scraper)
- [Comeet Jobs Scraper](https://apify.com/automation-lab/comeet-jobs-scraper)

Use this Actor when the target employer's public career page is hosted on Zoho Recruit.

### FAQ

#### Does this Actor require a Zoho Recruit account?

No.
It reads anonymous public employer career pages only.

#### Does it scrape candidate profiles or applications?

No.
Candidate, application, recruiter, and authenticated portal data are outside scope.

#### Can I scrape several employers in one run?

Yes.
Combine multiple URLs and tenant slugs; `maxItems` applies to the combined result.

#### Does it fetch each detail page?

No.
The public listing page already includes the promised fields and full description, so extra requests would increase cost and failure risk without adding value.
The Actor still constructs the canonical detail URL.

#### How are duplicates handled?

Records are deduplicated within a run by Zoho tenant plus stable job ID.
Duplicate URLs or duplicate slug/URL combinations do not create duplicate output.

#### Can I monitor deleted or closed jobs?

The Actor emits current public records from the page.
To detect removals, store results from successive scheduled runs and compare their stable keys.

#### Is a proxy supported?

No proxy is needed for the validated public route, so the Actor does not expose a proxy option.
This keeps execution simple and avoids unmeasured proxy cost.

#### Is the output real-time?

It reflects what the public Zoho Recruit page returned during the run.
Freshness therefore depends on both the employer's updates and your schedule.

#### What happens when Zoho changes its HTML?

The Actor validates the specific embedded dataset shape.
It fails visibly when that structure is absent or invalid, allowing the parser to be updated without silently publishing incomplete data.

# Actor input Schema

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

Public HTTPS URLs on \*.zohorecruit.com that contain /jobs/Careers. Listing or individual job URLs are accepted and normalized to the tenant career page.

## `tenantSlugs` (type: `array`):

Employer subdomains without .zohorecruit.com, for example accountingbaba. You can combine these with career page URLs.

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

Stop after saving this many unique public job openings across all tenants.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://accountingbaba.zohorecruit.com/jobs/Careers"
    }
  ],
  "tenantSlugs": [],
  "maxItems": 20
}
```

# Actor output Schema

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

Open the normalized public job records in the overview dataset view.

# 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://accountingbaba.zohorecruit.com/jobs/Careers"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/zoho-recruit-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://accountingbaba.zohorecruit.com/jobs/Careers" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/zoho-recruit-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://accountingbaba.zohorecruit.com/jobs/Careers"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/zoho-recruit-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zoho Recruit Jobs Scraper",
        "description": "Extract normalized public openings from employer career sites hosted on Zoho Recruit, including IDs, titles, locations, dates, full descriptions, and canonical URLs.",
        "version": "0.1",
        "x-build-id": "Wtoc6WWgd3KMPGrTc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~zoho-recruit-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-zoho-recruit-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~zoho-recruit-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-zoho-recruit-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~zoho-recruit-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-zoho-recruit-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": {
                    "startUrls": {
                        "title": "Zoho Recruit career page URLs",
                        "type": "array",
                        "description": "Public HTTPS URLs on *.zohorecruit.com that contain /jobs/Careers. Listing or individual job URLs are accepted and normalized to the tenant career page.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "tenantSlugs": {
                        "title": "Tenant slugs",
                        "type": "array",
                        "description": "Employer subdomains without .zohorecruit.com, for example accountingbaba. You can combine these with career page URLs.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 63
                        },
                        "default": []
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique public job openings across all tenants.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```