# Remote Rocketship Jobs Scraper (`automation-lab/remote-rocketship-jobs-scraper`) Actor

Extract remote job listings from Remote Rocketship by keyword, URL, tech stack, location, seniority, and employment type.

- **URL**: https://apify.com/automation-lab/remote-rocketship-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

Pay per event

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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

## Remote Rocketship Jobs Scraper 🚀💼

Extract remote job listings from Remote Rocketship into a clean Apify dataset.

This actor is built for repeatable remote-job research, lead sourcing, job-board enrichment, and labor-market monitoring.

### What does Remote Rocketship Jobs Scraper do?

Remote Rocketship Jobs Scraper collects public job listings from `remoterocketship.com`.

It searches Remote Rocketship by keyword and exports normalized job rows.

You can search for skills, job titles, departments, categories, or company names.

The scraper returns job title, company, job URL, location, employment type, seniority, tech stack, salary fields when available, description summary, posted date, and source query.

### Who is it for?

Recruiters use it to monitor new remote jobs by skill, function, and region.

Sourcing teams use it to discover companies hiring for specific roles.

Job-board operators use it to build remote-work feeds and enrichment pipelines.

Labor-market analysts use it to track demand for skills such as Python, React, SQL, product management, and customer support.

Sales teams use it to find companies with active hiring signals.

Career tools use it to power saved searches and candidate alerts.

### Why use this scraper?

Remote Rocketship contains a broad set of remote-first job listings.

Manual browsing is slow when you need structured exports.

This actor makes the data available as JSON, CSV, Excel, XML, and API responses.

It is HTTP-first and avoids browser overhead.

It deduplicates jobs across multiple queries.

It includes source query metadata so downstream workflows know why each job was collected.

### Typical use cases

- Track new remote engineering jobs by tech stack.
- Build a weekly remote-job digest.
- Enrich a company database with current hiring activity.
- Monitor remote customer support openings.
- Compare demand for skills across remote job categories.
- Feed recruiting dashboards with fresh job URLs.
- Collect labor-market signals for sales prospecting.
- Export remote roles for market research.

### Data you can extract

| Field | Description |
| --- | --- |
| `jobId` | Remote Rocketship job identifier |
| `title` | Job title |
| `companyName` | Hiring company name |
| `companyUrl` | Company website when available |
| `companyLinkedInUrl` | Company LinkedIn URL when available |
| `jobUrl` | Original job application URL |
| `remoteRocketshipUrl` | Remote Rocketship listing URL |
| `location` | Location or remote region |
| `locationType` | Remote, hybrid, or onsite classification |
| `employmentType` | Full-time, contract, part-time, etc. |
| `category` | Normalized job category |
| `function` | Job function |
| `seniority` | Entry, junior, mid-level, senior, or lead labels |
| `techStack` | Technologies listed for the role |
| `requiredLanguages` | Required language codes |
| `salary` | Salary range as displayed by the source |
| `salaryMin` | Parsed salary minimum when available |
| `salaryMax` | Parsed salary maximum when available |
| `salaryCurrency` | Parsed salary currency when available |
| `descriptionSummary` | Short public job summary |
| `postedAt` | Posted timestamp from Remote Rocketship |
| `validUntilDate` | Expiration date when available |
| `isOnLinkedIn` | Whether the job appears on LinkedIn |
| `isPromoted` | Whether the listing is promoted |
| `sourceQuery` | Query that found the job |
| `sourceUrl` | Search URL used for extraction |
| `scrapedAt` | Timestamp of the actor run |

### How much does it cost to scrape Remote Rocketship jobs?

This actor uses pay-per-event pricing.

You pay a small start fee plus a per-job fee for each saved dataset item.

Current pricing: $0.005 per run start. Per saved job: FREE $0.000031239, BRONZE $0.000027164, SILVER $0.000021188, GOLD $0.000016299, PLATINUM $0.000010866, DIAMOND $0.00001.

The run preview in Apify shows exact estimated charges before large runs.

Use `maxItems` to control cost.

Start with 20-100 jobs to validate your workflow.

Scale up only after confirming that the output matches your needs.

### Input options

#### Search queries

Use `queries` to search Remote Rocketship by keyword.

Examples:

- `python`
- `javascript`
- `data analyst`
- `customer support`
- `product manager`
- `salesforce`
- `remote recruiter`

#### Start URLs

Use `startUrls` when you already have a Remote Rocketship search URL.

Example:

```json
[
  { "url": "https://www.remoterocketship.com/?query=python" }
]
````

The actor reads the query parameter and uses it as a source query.

#### Maximum jobs

Use `maxItems` to stop after a fixed number of unique job rows.

The default example uses 100 jobs across several queries.

#### Optional filters

You can pass optional Remote Rocketship-style filters:

- `locationFilters`
- `techStackFilters`
- `seniorityFilters`
- `employmentTypeFilters`
- `minSalary`
- `includeJobsWithoutSalary`
- `sortBy`

### Example input

```json
{
  "queries": [
    "python",
    "javascript",
    "data analyst",
    "customer support",
    "product manager"
  ],
  "maxItems": 100,
  "sortBy": "DateAdded"
}
```

### Example output

```json
{
  "jobId": "19410207",
  "title": "Senior Data Scientist",
  "companyName": "Addvisor Group",
  "companyUrl": "https://addvisor.com.br",
  "companyLinkedInUrl": "https://www.linkedin.com/company/addvisor-group",
  "jobUrl": "https://jobs.quickin.io/addvisor/jobs/6a3d443c9277d000141d80a3",
  "remoteRocketshipUrl": "https://www.remoterocketship.com/remote-jobs/senior-data-scientist-worldwide-remote",
  "location": "Brazil",
  "locationType": "remote",
  "employmentType": "full-time",
  "category": "Data Scientist",
  "function": "Data Scientist",
  "seniority": ["senior"],
  "techStack": ["Python", "SQL", "Pandas"],
  "requiredLanguages": ["pt"],
  "salary": null,
  "salaryMin": null,
  "salaryMax": null,
  "salaryCurrency": null,
  "descriptionSummary": "Senior Data Scientist developing analytical models to support business decisions.",
  "postedAt": "2026-06-26T02:45:18.803+00:00",
  "validUntilDate": null,
  "isOnLinkedIn": true,
  "isPromoted": false,
  "sourceQuery": "python",
  "sourceUrl": "https://www.remoterocketship.com/?query=python",
  "scrapedAt": "2026-06-26T03:12:45.607Z"
}
```

### How to run it

1. Open the actor on Apify.
2. Add search queries or Remote Rocketship start URLs.
3. Set `maxItems`.
4. Add optional filters if needed.
5. Click **Start**.
6. Download results from the dataset tab.
7. Connect the dataset to your workflow through the Apify API.

### Tips for best results

Use several specific queries instead of one very broad query.

Combine job titles with skills for more targeted output.

Use `maxItems` to control costs during testing.

Keep defaults for a quick first run.

Use source queries to segment downstream exports.

Deduplicate downstream by `jobId` or `jobUrl` if combining multiple actor runs.

### Integrations

Send new jobs to Google Sheets for recruiting review.

Load the dataset into Airtable for job-board curation.

Trigger Slack alerts when matching jobs appear.

Sync job URLs into a CRM as company hiring signals.

Feed the output into an LLM workflow to classify roles or generate summaries.

Store historical runs in a warehouse to track remote hiring trends.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/remote-rocketship-jobs-scraper').call({
  queries: ['python', 'data analyst'],
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/remote-rocketship-jobs-scraper').call(run_input={
    'queries': ['python', 'data analyst'],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~remote-rocketship-jobs-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["python","data analyst"],"maxItems":100}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or another MCP client through Apify MCP.

MCP tool URL:

```text
https://mcp.apify.com/?tools=automation-lab/remote-rocketship-jobs-scraper
```

Claude Code setup:

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

Claude Desktop JSON config:

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

Example prompts:

- "Find 100 remote Python jobs and summarize the most common tech stacks."
- "Export remote customer support roles from Remote Rocketship into a table."
- "Monitor product manager jobs and highlight companies hiring in Europe."

### Quality and freshness

Remote Rocketship updates listings frequently.

The actor captures the public data available at run time.

A job may expire or redirect after extraction.

Use `scrapedAt` and `postedAt` to understand freshness.

### Limitations

The actor extracts public Remote Rocketship listings only.

It does not apply to jobs or bypass application forms.

Some salary values are not published by the source.

Some company fields may be missing when Remote Rocketship does not provide them.

Search pagination is source-dependent, so broad coverage is best achieved with multiple targeted queries.

### FAQ

#### Is Remote Rocketship Jobs Scraper an API?

It works like a hosted API on Apify. You can start runs from the UI, API, SDK, scheduler, webhooks, or MCP.

#### Can I monitor jobs every day?

Yes. Schedule the actor on Apify and compare each dataset with prior runs using `jobId` or `jobUrl`.

### Troubleshooting

#### Why did I get fewer jobs than `maxItems`?

The source may have fewer unique jobs for the queries you provided.

Add more queries or broaden your search terms.

#### Why is salary empty?

Many job listings do not publish salary ranges.

The actor preserves salary fields when Remote Rocketship exposes them.

#### Why do I see duplicate companies?

A company can have many active roles.

Deduplication is by job, not by company.

### Legality

This actor extracts publicly available job listing metadata.

You are responsible for using the output in compliance with applicable laws, platform terms, and privacy rules.

Do not use scraped data for spam, discrimination, or prohibited employment decisions.

### Related scrapers

Explore related Automation Lab actors:

- https://apify.com/automation-lab/ashby-jobs-scraper
- https://apify.com/automation-lab/greenhouse-jobs-scraper
- https://apify.com/automation-lab/lever-jobs-scraper
- https://apify.com/automation-lab/indeed-jobs-scraper
- https://apify.com/automation-lab/linkedin-jobs-scraper

### Support

If a run fails, open the run log and include the run URL in your support request.

Share the input JSON so the issue can be reproduced quickly.

### Changelog

Initial version extracts Remote Rocketship job listings by query and start URL.

# Actor input Schema

## `queries` (type: `array`):

Keywords to search on Remote Rocketship, such as job titles, skills, categories, or company names. Multiple queries are combined and duplicates are removed.

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

Optional Remote Rocketship URLs, for example https://www.remoterocketship.com/?query=python. The scraper reads the query parameter and also supports HTML extraction from the page.

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

Maximum number of job rows to save across all queries and start URLs.

## `locationFilters` (type: `array`):

Remote Rocketship location filter values, such as Worldwide, United States, Europe, Canada, or a country name.

## `techStackFilters` (type: `array`):

Technologies to filter for, such as Python, SQL, React, AWS, Go, or Salesforce.

## `seniorityFilters` (type: `array`):

Seniority labels to pass to Remote Rocketship, for example entry-level, junior, mid-level, senior, or lead.

## `employmentTypeFilters` (type: `array`):

Employment types such as full-time, part-time, contract, internship, or freelance.

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

Optional minimum salary filter. Leave empty to include all salary ranges.

## `includeJobsWithoutSalary` (type: `boolean`):

When a minimum salary is set, keep jobs that do not publish salary information.

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

Remote Rocketship sort mode. DateAdded returns the newest jobs first.

## Actor input object example

```json
{
  "queries": [
    "python",
    "data analyst",
    "customer support",
    "product manager",
    "javascript"
  ],
  "startUrls": [
    {
      "url": "https://www.remoterocketship.com/?query=python"
    }
  ],
  "maxItems": 20,
  "locationFilters": [],
  "techStackFilters": [],
  "seniorityFilters": [],
  "employmentTypeFilters": [],
  "includeJobsWithoutSalary": true,
  "sortBy": "DateAdded"
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "python",
        "data analyst",
        "customer support",
        "product manager",
        "javascript"
    ],
    "startUrls": [
        {
            "url": "https://www.remoterocketship.com/?query=python"
        }
    ],
    "maxItems": 20,
    "locationFilters": [],
    "techStackFilters": [],
    "seniorityFilters": [],
    "employmentTypeFilters": [],
    "includeJobsWithoutSalary": true,
    "sortBy": "DateAdded"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/remote-rocketship-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 = {
    "queries": [
        "python",
        "data analyst",
        "customer support",
        "product manager",
        "javascript",
    ],
    "startUrls": [{ "url": "https://www.remoterocketship.com/?query=python" }],
    "maxItems": 20,
    "locationFilters": [],
    "techStackFilters": [],
    "seniorityFilters": [],
    "employmentTypeFilters": [],
    "includeJobsWithoutSalary": True,
    "sortBy": "DateAdded",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/remote-rocketship-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 '{
  "queries": [
    "python",
    "data analyst",
    "customer support",
    "product manager",
    "javascript"
  ],
  "startUrls": [
    {
      "url": "https://www.remoterocketship.com/?query=python"
    }
  ],
  "maxItems": 20,
  "locationFilters": [],
  "techStackFilters": [],
  "seniorityFilters": [],
  "employmentTypeFilters": [],
  "includeJobsWithoutSalary": true,
  "sortBy": "DateAdded"
}' |
apify call automation-lab/remote-rocketship-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Remote Rocketship Jobs Scraper",
        "description": "Extract remote job listings from Remote Rocketship by keyword, URL, tech stack, location, seniority, and employment type.",
        "version": "0.1",
        "x-build-id": "vhpk8OUopOiXxGOvh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~remote-rocketship-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-remote-rocketship-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~remote-rocketship-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-remote-rocketship-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~remote-rocketship-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-remote-rocketship-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": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search on Remote Rocketship, such as job titles, skills, categories, or company names. Multiple queries are combined and duplicates are removed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Remote Rocketship search URLs",
                        "type": "array",
                        "description": "Optional Remote Rocketship URLs, for example https://www.remoterocketship.com/?query=python. The scraper reads the query parameter and also supports HTML extraction from the page.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of job rows to save across all queries and start URLs.",
                        "default": 20
                    },
                    "locationFilters": {
                        "title": "Location filters",
                        "type": "array",
                        "description": "Remote Rocketship location filter values, such as Worldwide, United States, Europe, Canada, or a country name.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "techStackFilters": {
                        "title": "Tech stack filters",
                        "type": "array",
                        "description": "Technologies to filter for, such as Python, SQL, React, AWS, Go, or Salesforce.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "seniorityFilters": {
                        "title": "Seniority filters",
                        "type": "array",
                        "description": "Seniority labels to pass to Remote Rocketship, for example entry-level, junior, mid-level, senior, or lead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "employmentTypeFilters": {
                        "title": "Employment type filters",
                        "type": "array",
                        "description": "Employment types such as full-time, part-time, contract, internship, or freelance.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minSalary": {
                        "title": "Minimum salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional minimum salary filter. Leave empty to include all salary ranges."
                    },
                    "includeJobsWithoutSalary": {
                        "title": "Include jobs without salary",
                        "type": "boolean",
                        "description": "When a minimum salary is set, keep jobs that do not publish salary information.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "DateAdded",
                            "Relevance"
                        ],
                        "type": "string",
                        "description": "Remote Rocketship sort mode. DateAdded returns the newest jobs first.",
                        "default": "DateAdded"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
