# Computrabajo Job Listings Scraper — Argentina & LatAm Salaries (`mfapitools/computrabajo-jobs-scraper`) Actor

Structured job listings from Computrabajo across 19 LatAm countries — including Argentina, Mexico, and Colombia — with salary, contract type, work mode, and full description. Pay per job scraped.

- **URL**: https://apify.com/mfapitools/computrabajo-jobs-scraper.md
- **Developed by:** [Mariano Ferreras](https://apify.com/mfapitools) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 job scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Computrabajo Jobs Scraper — LatAm Job Listings

> **Pay-per-event pricing.** This actor extracts public job postings from Computrabajo, a job board operating across 19 Spanish-speaking Latin American countries. Structured JSON: title, company, location, salary (when listed), contract type, work mode, posting date. There are 5+ Computrabajo scrapers on Apify — we compete on price ($0.0015/job) rather than feature breadth.

The most important limitation: most LatAm job postings list salary as "A convenir" (negotiable) — you will get many null salary fields.

---

### What it does

This actor scrapes job postings from Computrabajo across 19 Spanish-speaking Latin American countries.

It uses rotating proxies for reliability and validates every output item against a strict schema. Incremental runs are supported via the `sinceDate` field — skip jobs older than your last run. Salary data is available when listings include it; many LatAm postings say "A convenir" (negotiable) and will have null salary fields.

Bumeran support (Argentina, Mexico, Colombia, Peru, Chile, Venezuela, Panama) is implemented in the parser layer and will be activated in v1.1 once a Playwright-based runner is wired up (Bumeran is a JavaScript SPA requiring browser rendering).

---

### Use cases

- **Labor market analytics** — track hiring trends, salary movements, and job demand by role, location, and country across all of LatAm in one unified feed.
- **HR tech pipeline** — power job aggregators, candidate matching engines, or alert systems with fresh Computrabajo and empleos computrabajo data across 19 countries without building per-country scrapers.
- **Salary data LatAm** — extract salary ranges (when listed) from thousands of job postings to build salary band models for Argentina, Mexico, Colombia, and beyond.
- **Recruiter intelligence** — monitor competitor hiring activity, identify high-growth companies, and benchmark compensation ranges by role and region. Enable `enrichCompany` to add each employer's verified badge, average rating, and follower/review counts to every job record.
- **Automated job alerts** — run on a schedule with `sinceDate` to fetch only new listings since the last run, then push to Slack/email/your ATS.

---

### Input example

```json
{
  "sources": ["computrabajo"],
  "country": "ar",
  "keyword": "desarrollador python",
  "location": "buenos aires",
  "maxItems": 100,
  "sinceDate": "2026-07-01",
  "useResidentialProxy": false,
  "enrichCompany": false
}
````

| Field | Type | Default | Description |
|---|---|---|---|
| `sources` | array | `["computrabajo"]` | Data sources to scrape. Options: `"computrabajo"`, `"bumeran"` (Bumeran is stub in v1.0) |
| `country` | enum | `"ar"` | Country code for Computrabajo. Options: `ar`, `mx`, `co`, `pe`, `cl`, `ec`, `ve`, `bo`, `py`, `uy`, `cr`, `pa`, `do`, `gt`, `hn`, `sv`, `ni`, `cu`, `pr` |
| `keyword` | string | `"desarrollador"` | Job title or keyword to search for |
| `location` | string | *(none)* | Optional city or province to filter by (e.g. `"buenos aires"`, `"monterrey"`) |
| `sinceDate` | string | *(none)* | ISO date `YYYY-MM-DD`. Skip jobs posted before this date. Useful for incremental runs. |
| `maxItems` | integer | `50` | Maximum number of jobs to collect. `0` = unlimited |
| `useResidentialProxy` | boolean | `false` | Upgrade to residential proxies (not required for Computrabajo; recommended for Bumeran when activated) |
| `enrichCompany` | boolean | `false` | Fetch each job's company profile page and attach a `companyDetails` object (see below). Each distinct company is fetched once per run and cached — cost scales with distinct employers, not job count. Off by default so the default run's output and cost are unchanged. |

***

### Output example

```json
[
  {
    "url": "https://ar.computrabajo.com/ofertas-de-trabajo/oferta-de-trabajo-de-senior-backend-python-developer-remoto-para-residentes-en-argentina-en-monserrat-F2A4E9D19A683AFB61373E686DCF3405",
    "title": "Senior Backend Python Developer",
    "company": "Kaizen Recursos Humanos",
    "location": "Monserrat, Capital Federal",
    "salary": {
      "raw": "A convenir",
      "min": null,
      "max": null,
      "currency": null
    },
    "contractType": "Contrato por tiempo indeterminado",
    "workMode": "remote",
    "postedDate": "2026-07-23",
    "description": "En KaizenRH buscamos Senior Backend Python Developer para trabajar dentro de Compañía líder en desarrollo de software...",
    "source": "computrabajo",
    "country": "ar"
  }
]
```

| Field | Type | Notes |
|---|---|---|
| `url` | string | Canonical job detail page URL |
| `title` | string | Job title as listed |
| `company` | string | Hiring company name |
| `location` | string | Location string as scraped (e.g. `"Belgrano, Capital Federal"`) |
| `salary.raw` | string | Raw salary text from listing (e.g. `"$ 1.200.000 – $ 1.500.000 ARS"`) |
| `salary.min` | number|null | Parsed minimum salary amount |
| `salary.max` | number|null | Parsed maximum salary amount |
| `salary.currency` | string|null | Currency code (`"ARS"`, `"USD"`, `"MXN"`, etc.) |
| `contractType` | string|null | e.g. `"Contrato por tiempo indeterminado"`, `"Freelance"` |
| `workMode` | `"remote"\|"hybrid"\|"onsite"\|null` | Detected from listing text/tags |
| `postedDate` | string|null | ISO date `YYYY-MM-DD` normalized from relative ("Hace 2 días") or absolute dates |
| `description` | string | Full job description text (HTML stripped) |
| `source` | `"computrabajo"\|"bumeran"` | Data source identifier |
| `country` | string | Country code used for this search |

***

### Company enrichment (`enrichCompany: true`)

When `enrichCompany` is enabled, each job record gets an additional `companyDetails` object built from two public, unauthenticated sources: the structured data (JSON-LD) already embedded in the job's own detail page (free — no extra request), and the employer's Computrabajo company profile page (one extra request per **distinct** company, cached for the rest of the run).

```json
{
  "url": "https://ar.computrabajo.com/ofertas-de-trabajo/oferta-de-trabajo-de-senior-backend-python-developer-...",
  "title": "Senior Backend Python Developer",
  "company": "Kaizen Recursos Humanos",
  "companyDetails": {
    "id": "AFD521AD0DEE542B",
    "name": "Kaizen Recursos Humanos",
    "profileUrl": "https://ar.computrabajo.com/empresas/ofertas-de-trabajo-de-kaizen-recursos-humanos-AFD521AD0DEE542B",
    "industry": "RRHH / Personal",
    "logoUrl": "https://ii.ct-stc.com/5/logos/empresas/2024/07/31/bccd8d9f7e294f87ae9e103002884thumbnail.png",
    "verified": true,
    "rating": 4.2,
    "reviewCount": 234,
    "followerCount": 2441,
    "jobCount": 12
  },
  "...": "(other job fields as above)"
}
```

| Field | Type | Notes |
|---|---|---|
| `companyDetails.id` | string | Computrabajo's internal company identifier (hex string, used to build the profile URL) |
| `companyDetails.name` | string | Company name from the profile page (falls back to the job-posting name if the profile fetch failed) |
| `companyDetails.profileUrl` | string|null | Public company profile page URL |
| `companyDetails.industry` | string|null | Industry/category taxonomy Computrabajo assigns to the posting (e.g. `"Informática / Software"`, `"RRHH / Personal"`) — comes from the job's own structured data, always populated when enrichment runs |
| `companyDetails.logoUrl` | string|null | Company logo image URL. `null` when the company has not uploaded a real logo (Computrabajo shows a default placeholder in that case, which we detect and treat as no logo) |
| `companyDetails.verified` | boolean|null | Computrabajo's "Empresa verificada" badge. `null` only if the profile page fetch failed |
| `companyDetails.rating` | number|null | Average employer rating, 0–5. `null` when the company has no reviews yet, or the profile fetch failed |
| `companyDetails.reviewCount` | number|null | Number of employee reviews. `null` when zero/unavailable |
| `companyDetails.followerCount` | number|null | Followers on the company's Computrabajo profile. `null` when unavailable |
| `companyDetails.jobCount` | number|null | Number of the company's currently active job postings. `null` when unavailable |

When `enrichCompany` is `false` (the default), `companyDetails` is omitted entirely — job records are byte-for-byte the same shape as before this field existed.

**What we checked and confirmed does NOT exist publicly on Computrabajo** (so we don't fabricate it): a structured "company size" / employee-count band, and any industry/sector taxonomy beyond the single per-posting `industry` string above. Some competing scrapers advertise these; on live inspection of both verified and unverified company profile pages (with and without reviews) neither field is present in the HTML or in Computrabajo's schema.org JSON-LD.

**Cost note:** enrichment adds one extra HTTP fetch per distinct company (not per job), which is not separately charged — there is no `company-enriched` pricing event. It only increases the actor's own compute time slightly, which we absorb; you pay the same `job-scraped` price per job whether or not `enrichCompany` is on.

***

### Pricing

This actor uses **pay-per-event** pricing. You are never charged for failed requests, quarantined items, or jobs that fail schema validation.

| Event | Price | Description |
|---|---|---|
| `job-scraped` | $1.50 / 1,000 jobs | Charged once per successfully validated, schema-passing job pushed to the dataset |

Use a small `maxItems` for test runs (e.g. `5`) to keep costs minimal while verifying selectors. At $1.50/1K, a monthly scan of 500 jobs costs $0.75 — no rental, no subscription.

***

### Use with AI agents (MCP)

This actor is available as a tool for AI assistants via the Apify MCP server. Agents can call it to **scrape Latin American jobs from Computrabajo** directly — no Apify console needed, just a single function call.

#### MCP setup

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

#### Example agent prompts

- "Scrape the latest Python developer jobs in Argentina from Computrabajo"
- "Get all remote React jobs posted in Mexico in the last week"
- "Pull salary data for senior engineering roles across Chile, Colombia, and Peru"

The actor returns structured JSON with the same fields shown above. Agentic workflows (Claude Code, Cursor, any MCP-compatible AI) can fetch job listings and analyze hiring trends in the same run.

***

### Limitations

- **Computrabajo only in v1.0** — Bumeran parsers and URL builders are implemented and tested but the live runner requires a Playwright-based crawler (Bumeran is a JavaScript SPA). Bumeran activation is planned for v1.1.
- **Salary not always listed** — many LatAm job postings say "A convenir" (negotiable). `salary` will be `null` in those cases. This is a data limitation from the source site, not a scraper bug.
- **Computrabajo proxy tier** — datacenter proxies work for Computrabajo in most countries (confirmed via live testing on AR). If you observe blocking (especially on MX or CO domains), enable `useResidentialProxy: true`.
- **`sinceDate` accuracy** — Computrabajo uses relative dates ("Hace 2 horas", "Hace 3 días") that are normalized to ISO dates at scrape time. Accuracy degrades for old listings (weeks/months) where the relative label is coarse.
- **Public data only** — this actor scrapes public job listings only. It does not and cannot access applicant CVs, candidate profiles, or login-gated data. Company names of hiring firms are public information.
- **Robots.txt compliance** — the scraper uses only allowed URL paths (`/trabajo-de-{keyword}`, `/ofertas-de-trabajo/...`). Disallowed paths (`/hojas-de-vida/`, `/curriculums/`, `/Ajax/`) are never requested.
- **Rate limiting** — fetching is intentionally polite (sequential requests with Crawlee's default concurrency). Very large `maxItems` values will take proportionally longer. Run the actor with a schedule for regular incremental harvests rather than large one-time bulk pulls.
- **`enrichCompany` has no "company size" or structured sector field** — confirmed absent on Computrabajo's public pages (see the Company enrichment section above). `companyDetails.industry` is the closest thing available and comes from the job posting's own taxonomy tag.

***

### Changelog

See [CHANGELOG.md](./CHANGELOG.md).

# Actor input Schema

## `sources` (type: `array`):

Data sources to scrape. Only 'computrabajo' is active in v1.0; 'bumeran' is planned for v1.1 and is skipped with a warning if selected.

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

Computrabajo country site to search.

## `keyword` (type: `string`):

Job search keyword, e.g. 'desarrollador python', 'contador', 'ventas'.

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

City or province filter, e.g. 'buenos aires', 'cordoba'.

## `sinceDate` (type: `string`):

ISO date YYYY-MM-DD. Jobs with an older posted date are skipped — useful for incremental daily runs that only pay for new listings.

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

Maximum number of jobs to collect. 0 = unlimited. You are only charged for valid jobs actually delivered.

## `useResidentialProxy` (type: `boolean`):

Not required for Computrabajo. Reserved for sources with stronger bot protection.

## `enrichCompany` (type: `boolean`):

Fetch each job's Computrabajo company profile page and attach a companyDetails object (verified-employer badge, rating, review/follower/job counts, industry, logo). Off by default — the default run's cost and output are unchanged. Each distinct company is fetched at most once per run (cached), so cost scales with distinct employers in your results, not with job count. Slightly increases compute time per run.

## Actor input object example

```json
{
  "sources": [
    "computrabajo"
  ],
  "country": "ar",
  "keyword": "desarrollador",
  "maxItems": 50,
  "useResidentialProxy": false,
  "enrichCompany": false
}
```

# Actor output Schema

## `jobs` (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 = {
    "sources": [
        "computrabajo"
    ],
    "country": "ar",
    "keyword": "desarrollador",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("mfapitools/computrabajo-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 = {
    "sources": ["computrabajo"],
    "country": "ar",
    "keyword": "desarrollador",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("mfapitools/computrabajo-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 '{
  "sources": [
    "computrabajo"
  ],
  "country": "ar",
  "keyword": "desarrollador",
  "maxItems": 50
}' |
apify call mfapitools/computrabajo-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Computrabajo Job Listings Scraper — Argentina & LatAm Salaries",
        "description": "Structured job listings from Computrabajo across 19 LatAm countries — including Argentina, Mexico, and Colombia — with salary, contract type, work mode, and full description. Pay per job scraped.",
        "version": "0.1",
        "x-build-id": "UgUwyKreYJbU2G9dE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mfapitools~computrabajo-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mfapitools-computrabajo-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/mfapitools~computrabajo-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-mfapitools-computrabajo-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/mfapitools~computrabajo-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-mfapitools-computrabajo-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": [
                    "keyword"
                ],
                "properties": {
                    "sources": {
                        "title": "Sources",
                        "type": "array",
                        "description": "Data sources to scrape. Only 'computrabajo' is active in v1.0; 'bumeran' is planned for v1.1 and is skipped with a warning if selected.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "computrabajo",
                                "bumeran"
                            ],
                            "enumTitles": [
                                "Computrabajo",
                                "Bumeran (v1.1, skipped for now)"
                            ]
                        },
                        "default": [
                            "computrabajo"
                        ]
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "ar",
                            "mx",
                            "co",
                            "pe",
                            "cl",
                            "ec",
                            "ve",
                            "bo",
                            "py",
                            "uy",
                            "cr",
                            "pa",
                            "do",
                            "gt",
                            "hn",
                            "sv",
                            "ni",
                            "cu",
                            "pr"
                        ],
                        "type": "string",
                        "description": "Computrabajo country site to search.",
                        "default": "ar"
                    },
                    "keyword": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Job search keyword, e.g. 'desarrollador python', 'contador', 'ventas'.",
                        "default": "desarrollador"
                    },
                    "location": {
                        "title": "Location (optional)",
                        "type": "string",
                        "description": "City or province filter, e.g. 'buenos aires', 'cordoba'."
                    },
                    "sinceDate": {
                        "title": "Only jobs posted since (optional)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "ISO date YYYY-MM-DD. Jobs with an older posted date are skipped — useful for incremental daily runs that only pay for new listings."
                    },
                    "maxItems": {
                        "title": "Max jobs",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of jobs to collect. 0 = unlimited. You are only charged for valid jobs actually delivered.",
                        "default": 50
                    },
                    "useResidentialProxy": {
                        "title": "Use residential proxies",
                        "type": "boolean",
                        "description": "Not required for Computrabajo. Reserved for sources with stronger bot protection.",
                        "default": false
                    },
                    "enrichCompany": {
                        "title": "Enrich with company profile data",
                        "type": "boolean",
                        "description": "Fetch each job's Computrabajo company profile page and attach a companyDetails object (verified-employer badge, rating, review/follower/job counts, industry, logo). Off by default — the default run's cost and output are unchanged. Each distinct company is fetched at most once per run (cached), so cost scales with distinct employers in your results, not with job count. Slightly increases compute time per run.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
