# RemoteOK Jobs Scraper (`parsebird/remoteok-jobs-scraper`) Actor

Scrape remote job listings from RemoteOK.com — titles, companies, salaries, tags, locations, and apply links. Filter by skill tags, keyword, and minimum salary. No proxy or authentication needed. Export as JSON, CSV, Excel.

- **URL**: https://apify.com/parsebird/remoteok-jobs-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** Jobs, Automation, AI
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 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.
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

### RemoteOK Jobs Scraper

Scrape remote job listings from [RemoteOK.com](https://remoteok.com) — titles, companies, salaries, tags, locations, and apply links. Filter by skill tags, keyword, and minimum salary. No proxy or authentication needed.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Extract structured remote job data from RemoteOK's public API — filter by 50+ skill tags (Python, JavaScript, React, DevOps, Design, etc.), set minimum salary thresholds, and get clean normalized output with 20 data fields per listing ready for analysis or integration.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

````

RemoteOK Jobs Scraper (parsebird/remoteok-jobs-scraper) — scrapes remote job listings from RemoteOK.com via their public JSON API. Inputs: tags (string\[], filter by skill tags like "python", "react", "devops"), keywordFilter (string, match title/company/tags), minSalary (int, USD minimum), filterNonTech (bool, remove non-tech roles), maxResults (int, default 100). Output: NormalizedJob objects with 20 fields including title, company\_name, salary\_min, salary\_max, currency, tags, location, apply\_url, posted\_at, description. Pricing: from $0.99/1,000 jobs (Gold) to $1.50/1,000 (Free). API: https://apify.com/parsebird/remoteok-jobs-scraper/api — Token: https://console.apify.com/account/integrations

````

### What is RemoteOK Jobs Scraper?

**RemoteOK Jobs Scraper** is an Apify Actor that extracts remote job listings from [RemoteOK.com](https://remoteok.com) — one of the largest remote-only job boards on the web. It uses RemoteOK's official public JSON API, so it requires **no proxy, no browser, and no authentication**. Each run returns up to ~100 of the most recent jobs per skill tag, normalized into a consistent 20-field schema and pushed to an [Apify Dataset](https://docs.apify.com/platform/storage/dataset).

Use it as a fast, affordable **RemoteOK API alternative** for job boards, recruitment pipelines, salary research, and AI-powered job search agents.

### What data can you extract from RemoteOK?

The RemoteOK Jobs Scraper returns structured data for each job listing with the following fields:

| Field | Description |
|-------|-------------|
| `title` | Job title (e.g., "Senior Python Engineer") |
| `company_name` | Hiring company name |
| `location` | Job location (usually "Worldwide" or "Remote") |
| `salary_min` | Minimum annual salary in USD (0 if not listed) |
| `salary_max` | Maximum annual salary in USD (0 if not listed) |
| `currency` | Salary currency ("USD" when salary is available, empty otherwise) |
| `tags` | Skill and category tags (e.g., python, react, devops) |
| `description` | Full job description with HTML stripped to plain text |
| `apply_url` | Direct link to the job application |
| `source_url` | Original listing URL on RemoteOK |
| `posted_at` | ISO 8601 timestamp when the job was posted |
| `company_slug` | URL-friendly company identifier |
| `work_mode` | Always "remote" (RemoteOK is remote-only) |
| `type` | Employment type (always "full-time") |
| `scraped_at` | Timestamp of when the data was collected |

### How to scrape RemoteOK

Follow these steps to extract remote job listings from RemoteOK using this Actor:

1. Go to the [RemoteOK Jobs Scraper](https://apify.com/parsebird/remoteok-jobs-scraper) page on Apify Store.
2. Click **Try for free** to open the Actor in Apify Console.
3. In the **Skill Tags** field, enter the tags you want to filter by (e.g., `python`, `javascript`, `react`). Leave empty for all recent jobs.
4. Optionally set a **Keyword Filter** to match against job titles, company names, and tags (e.g., "senior", "startup").
5. Set **Minimum Salary** if you want to exclude low-salary listings (jobs without salary data always pass through).
6. Toggle **Filter out non-tech roles** if you only want technical positions.
7. Set **Max Results** to control how many jobs to return (default: 100, prefill: 50).
8. Click **Start** and wait a few seconds — the actor is extremely fast since it uses a direct API.
9. When the run finishes, click the **Dataset** tab to preview results. Download as JSON, CSV, or Excel.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `tags` | string[] | No | `[]` | Skill/category tags to filter by. Each tag runs a separate API request. Results are deduplicated. Examples: `python`, `javascript`, `react`, `devops`, `design`. Leave empty for all recent jobs. |
| `keywordFilter` | string | No | `""` | Client-side keyword match against title, company, and tags. Case-insensitive. |
| `minSalary` | integer | No | `0` | Exclude jobs where `salary_max` is below this value (USD). Jobs without salary data always pass through. |
| `filterNonTech` | boolean | No | `false` | Remove clearly non-technical roles (receptionist, accountant, driver, nurse, etc.) from results. |
| `maxResults` | integer | No | `100` | Maximum total jobs to return across all tag requests. RemoteOK returns ~100 jobs per tag. |

### Output example

Each item in the Apify Dataset conforms to the NormalizedJob schema:

```json
{
  "id": "remote-founding-engineer-techcorp-1133500",
  "source": "remoteok",
  "source_url": "https://remoteOK.com/remote-jobs/remote-founding-engineer-techcorp-1133500",
  "apply_url": "https://remoteOK.com/remote-jobs/remote-founding-engineer-techcorp-1133500",
  "title": "Founding Engineer",
  "description": "We are looking for a Founding Engineer to build our core platform from the ground up...",
  "type": "full-time",
  "work_mode": "remote",
  "location": "Remote, USA",
  "salary_min": 180000,
  "salary_max": 220000,
  "currency": "USD",
  "company_name": "TechCorp",
  "company_slug": "techcorp",
  "company_url": "https://remoteok.com",
  "tags": ["python", "react", "aws", "backend"],
  "markets": ["python", "react", "aws", "backend"],
  "posted_at": "2026-06-16T00:00:24+00:00",
  "scraped_at": "2026-06-17T13:30:00.000Z",
  "data_source": "RemoteOK",
  "data_source_url": "https://remoteok.com"
}
````

Download results in **JSON, CSV, HTML, or Excel** format from the [Dataset tab](https://docs.apify.com/platform/storage/dataset) in Apify Console.

### Use cases

🔍 **Job board aggregation** — Combine RemoteOK data with other job sources to build comprehensive remote job boards.

📊 **Salary research** — Analyze salary ranges across different tech stacks and roles in the remote job market.

🤖 **AI job search agents** — Feed structured job data into LLM-powered assistants via the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp).

📈 **Remote work trend monitoring** — Schedule daily runs to track hiring trends, popular skills, and market shifts.

🔄 **Recruitment pipeline automation** — Use [Apify integrations](https://docs.apify.com/platform/integrations) to push new listings directly into your ATS or CRM.

💼 **Competitive intelligence** — Monitor which companies are hiring remotely, what skills they need, and what they pay.

### How much does it cost to scrape RemoteOK?

The RemoteOK Jobs Scraper uses [pay-per-event pricing](https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event). You are charged per 1,000 job listings scraped.

| Plan | Price per 1,000 jobs | Example: 5,000 jobs |
|------|---------------------|---------------------|
| Free | **$1.50** | $7.50 |
| Bronze | **$1.20** | $6.00 |
| Silver | **$1.10** | $5.50 |
| Gold | **$0.99** | $4.95 |

Platform compute usage is minimal — a typical run takes under 5 seconds and uses less than 0.005 compute units. No proxy costs since RemoteOK's API is public.

Apify offers a [free trial](https://apify.com/pricing) that includes $5 of platform credits — enough to scrape thousands of RemoteOK jobs at no cost.

### API usage examples

You can run the RemoteOK Jobs Scraper programmatically using the [Apify API](https://docs.apify.com/api/v2). Below are examples in Python and JavaScript.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "tags": ["python", "javascript"],
    "keywordFilter": "senior",
    "minSalary": 80000,
    "maxResults": 100,
}

run = client.actor("parsebird/remoteok-jobs-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['title']} at {item['company_name']} — {item['apply_url']}")
```

#### JavaScript

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });

const input = {
    tags: ['python', 'javascript'],
    keywordFilter: 'senior',
    minSalary: 80000,
    maxResults: 100,
};

const run = await client.actor('parsebird/remoteok-jobs-scraper').call(input);

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.log(`${item.title} at ${item.company_name} — ${item.apply_url}`);
});
```

You can also integrate this Actor with [Google Sheets](https://docs.apify.com/platform/integrations/google-sheets), [Slack](https://docs.apify.com/platform/integrations/slack), [Zapier](https://docs.apify.com/platform/integrations/zapier), [Make](https://docs.apify.com/platform/integrations/make), and other tools via Apify's [integrations](https://docs.apify.com/platform/integrations).

### Is it legal to scrape RemoteOK?

RemoteOK provides a [public JSON API](https://remoteok.com/api) that is openly accessible without authentication. This Actor uses that official API endpoint to retrieve job listings data.

RemoteOK's API Terms of Service require attribution — linking back to RemoteOK and mentioning them as the source. This Actor includes `source_url` and `data_source` fields in every result to support proper attribution.

For more information about the legality of web scraping, read Apify's blog post on [is web scraping legal](https://blog.apify.com/is-web-scraping-legal/).

### Related scrapers

ParseBird offers a full suite of job scrapers on Apify Store. Combine multiple scrapers for maximum coverage:

- **[Hiring.cafe Jobs Scraper](https://apify.com/parsebird/hiring-cafe-scraper)** — Search 2.8M+ aggregated job postings across 46 ATS platforms with 30+ filter options.
- **[BuiltIn Jobs Scraper](https://apify.com/parsebird/builtin-jobs-scraper)** — Scrape tech job listings from BuiltIn.com by keyword, location, and seniority.
- **[Dice Jobs Scraper](https://apify.com/parsebird/dice-jobs-scraper)** — Extract tech jobs from Dice.com with salary, skills, and company data.
- **[WeWorkRemotely Jobs Scraper](https://apify.com/parsebird/wwr-jobs-scraper)** — Scrape remote jobs from WeWorkRemotely.com across 11 category feeds.
- **[Wellfound Jobs Scraper](https://apify.com/parsebird/wellfound-jobs-scraper)** — Scrape startup jobs from Wellfound (AngelList) with salary and equity data.
- **[YC Jobs Scraper](https://apify.com/parsebird/yc-jobs-scraper)** — Extract job postings from Y Combinator's Work at a Startup platform.
- **[Dribbble Jobs Scraper](https://apify.com/parsebird/dribbble-jobs-scraper)** — Scrape design and creative job listings from Dribbble.
- **[StartupJobs Scraper](https://apify.com/parsebird/startup-jobs-scraper)** — Extract startup job listings from StartupJobs.com.
- **[Xing Jobs Scraper](https://apify.com/parsebird/xing-jobs-scraper)** — Scrape job listings from Xing, Europe's leading professional network.

### FAQ

**How many jobs can I get per run?**
RemoteOK's API returns approximately 100 of the most recent listings per tag. If you specify multiple tags (e.g., `python`, `javascript`, `react`), each tag fetches up to ~100 jobs, and the Actor deduplicates them automatically. A typical 3-tag run yields 150–250 unique jobs.

**How fresh is the data?**
RemoteOK's API returns the most recently posted listings. The data is as fresh as RemoteOK's own feed — typically listings from the past 1–2 weeks. Schedule [recurring runs](https://docs.apify.com/platform/schedules) daily or weekly to maintain an up-to-date job database.

**Why do most jobs show $0 salary?**
Only about 2–7% of RemoteOK listings include salary data. When salary is not disclosed, `salary_min` and `salary_max` are set to `0` and the `currency` field is empty. The `minSalary` filter only excludes jobs that have salary data below your threshold — jobs without salary data always pass through.

**Can I schedule recurring runs?**
Yes. Use Apify's [scheduling feature](https://docs.apify.com/platform/schedules) to run the Actor daily, weekly, or at any custom interval. Combine with [integrations](https://docs.apify.com/platform/integrations) to automatically push new jobs to Google Sheets, Slack, or your database.

**What skill tags can I use?**
RemoteOK supports 50+ skill tags including: `javascript`, `typescript`, `python`, `react`, `vue`, `node`, `php`, `ruby`, `golang`, `rust`, `java`, `kotlin`, `swift`, `flutter`, `devops`, `aws`, `docker`, `kubernetes`, `design`, `ux`, `marketing`, `sales`, `finance`, `legal`, `hr`, `writing`, `customer-support`, and many more.

**Does this Actor need a proxy?**
No. RemoteOK's API is publicly accessible and does not block automated requests. This makes the Actor extremely cheap to run since it incurs zero proxy costs.

**Can I use this with AI assistants?**
Yes. Use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) to connect this Actor to ChatGPT, Claude, Cursor, or any LLM that supports the Model Context Protocol. Copy the AI assistant block at the top of this README for a quick start.

**How do I report issues or request features?**
Visit the [Issues tab](https://apify.com/parsebird/remoteok-jobs-scraper/issues) on the Actor page. We respond to all feedback.

# Actor input Schema

## `tags` (type: `array`):

Filter jobs by skill or category tags. Each tag runs a separate API request. Results are deduplicated. Examples: python, javascript, react, devops, design. Leave empty to fetch all recent jobs.

## `keywordFilter` (type: `string`):

Client-side keyword filter applied after fetching. Matches against job title, company name, and tags. Case-insensitive. Example: senior, startup, engineer.

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

Exclude jobs where salary\_max is below this value (USD). Jobs without salary data always pass through. Set to 0 to disable.

## `filterNonTech` (type: `boolean`):

Remove clearly non-technical roles (receptionist, accountant, driver, nurse, etc.) from results.

## `maxResults` (type: `integer`):

Maximum total jobs to return across all tag requests. RemoteOK returns ~100 jobs per tag. Start with 50 for a quick test.

## Actor input object example

```json
{
  "tags": [
    "python"
  ],
  "keywordFilter": "",
  "minSalary": 0,
  "filterNonTech": false,
  "maxResults": 50
}
```

# Actor output Schema

## `dataset` (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 = {
    "tags": [
        "python"
    ],
    "keywordFilter": "",
    "minSalary": 0,
    "filterNonTech": false,
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/remoteok-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 = {
    "tags": ["python"],
    "keywordFilter": "",
    "minSalary": 0,
    "filterNonTech": False,
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/remoteok-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 '{
  "tags": [
    "python"
  ],
  "keywordFilter": "",
  "minSalary": 0,
  "filterNonTech": false,
  "maxResults": 50
}' |
apify call parsebird/remoteok-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RemoteOK Jobs Scraper",
        "description": "Scrape remote job listings from RemoteOK.com — titles, companies, salaries, tags, locations, and apply links. Filter by skill tags, keyword, and minimum salary. No proxy or authentication needed. Export as JSON, CSV, Excel.",
        "version": "1.2",
        "x-build-id": "DzlOW5laNGUWbGdlZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parsebird~remoteok-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parsebird-remoteok-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/parsebird~remoteok-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parsebird-remoteok-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/parsebird~remoteok-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parsebird-remoteok-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": {
                    "tags": {
                        "title": "Skill Tags",
                        "type": "array",
                        "description": "Filter jobs by skill or category tags. Each tag runs a separate API request. Results are deduplicated. Examples: python, javascript, react, devops, design. Leave empty to fetch all recent jobs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywordFilter": {
                        "title": "Keyword Filter",
                        "type": "string",
                        "description": "Client-side keyword filter applied after fetching. Matches against job title, company name, and tags. Case-insensitive. Example: senior, startup, engineer.",
                        "default": ""
                    },
                    "minSalary": {
                        "title": "Minimum Salary (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Exclude jobs where salary_max is below this value (USD). Jobs without salary data always pass through. Set to 0 to disable.",
                        "default": 0
                    },
                    "filterNonTech": {
                        "title": "Filter out non-tech roles",
                        "type": "boolean",
                        "description": "Remove clearly non-technical roles (receptionist, accountant, driver, nurse, etc.) from results.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum total jobs to return across all tag requests. RemoteOK returns ~100 jobs per tag. Start with 50 for a quick test.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```