# Himalayas Remote Jobs Scraper (`fetch_cat/himalayas-remote-jobs-scraper`) Actor

Scrape public Himalayas remote job listings with companies, salaries, locations, tags, descriptions, and application links.

- **URL**: https://apify.com/fetch\_cat/himalayas-remote-jobs-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.06 / 1,000 item extracteds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

## Himalayas Remote Jobs Scraper

Scrape public remote job listings from Himalayas.app and export structured records with companies, salaries, locations, tags, descriptions, and apply links.

### What does Himalayas Remote Jobs Scraper do?

Himalayas Remote Jobs Scraper helps you collect remote job listings from Himalayas.app into a clean Apify dataset.

Use it to monitor new roles, build lead lists, enrich job-board data, or analyze hiring demand across remote-first companies.

The actor can start from a Himalayas URL or build a search from keywords and filters.

It returns one row per job listing.

Each row is designed for CSV, Excel, JSON, API, webhook, and database workflows.

### Who is it for?

Recruiters use it to discover companies hiring for remote roles.

Job-board operators use it to backfill and monitor listings.

Labor-market analysts use it to track salary ranges and remote hiring patterns.

Sales teams use it to identify teams with active hiring signals.

Developers use it to connect Himalayas job data to internal tools.

### Why use this actor?

✅ No manual copy-paste from job pages.

✅ Structured salary fields when Himalayas publishes salary ranges.

✅ Public job URLs and company URLs included.

✅ Works with search, category, country, seniority, and job-type paths.

✅ Saves results directly to Apify datasets.

✅ Easy to schedule for recurring monitoring.

### What data can you extract?

| Field | Description |
| --- | --- |
| `jobId` | Himalayas job slug or public identifier |
| `title` | Job title |
| `companyName` | Hiring company name |
| `companyUrl` | Public Himalayas company page |
| `jobUrl` | Public Himalayas job page |
| `applicationUrl` | Himalayas application link when available |
| `location` | Applicant location or country requirement |
| `country` | Country/location requirement when published |
| `remoteRegion` | Remote region derived from location data |
| `salaryText` | Human-readable salary range |
| `salaryMin` | Minimum salary value when available |
| `salaryMax` | Maximum salary value when available |
| `currency` | Salary currency code |
| `salaryCurrency` | Salary currency code alias |
| `salaryPeriod` | Salary period such as month or year |
| `employmentType` | Full-time, contractor, part-time, or similar |
| `seniority` | Public seniority/experience description when available |
| `categoryTags` | Main category tags shown on the job page |
| `categories` | Main tags and categories |
| `tags` | Broader public tags found on the job page |
| `postedAt` | Public posting date |
| `validThrough` | Public expiration date when provided |
| `descriptionText` | Plain-text job description |
| `applyUrl` | Backward-compatible alias for the application link |
| `scrapedAt` | Timestamp of extraction |

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee charged when a run starts. Covers fixed startup cost. | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `item` | Charged per job record saved to the default dataset. | $0.12099 / 1,000 | $0.10521 / 1,000 | $0.08207 / 1,000 | $0.06313 / 1,000 | $0.04209 / 1,000 | $0.02946 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### Quick start

1. Open the actor on Apify.

2. Enter a `searchQuery`, such as `sales` or `data engineer`.

3. Set `maxItems` to a small value for your first run.

4. Keep `includeDetails` enabled if you want salaries and descriptions.

5. Start the run.

6. Download results from the Dataset tab.

### Input example

```json
{
  "searchQuery": "sales",
  "maxItems": 20,
  "includeDetails": true
}
````

### Input recipes

Search sales roles:

```json
{
  "searchQuery": "sales",
  "maxItems": 25,
  "includeDetails": true
}
```

Search engineering roles:

```json
{
  "category": "engineering",
  "maxItems": 50,
  "includeDetails": true
}
```

Search remote roles by country path:

```json
{
  "country": "united-states",
  "searchQuery": "customer support",
  "maxItems": 50,
  "includeDetails": true
}
```

### Start URL examples

You can also provide direct Himalayas URLs:

```json
{
  "startUrls": [
    { "url": "https://himalayas.app/jobs?search=sales" },
    { "url": "https://himalayas.app/jobs/engineering" }
  ],
  "maxItems": 100,
  "includeDetails": true
}
```

Use start URLs when you already know the exact Himalayas search, category, or company jobs page you want to monitor.

### Input settings

#### `startUrls`

Optional list of Himalayas URLs to crawl.

If this field is provided, the actor starts from those pages.

#### `searchQuery`

Keyword query used on Himalayas job search.

Examples: `sales`, `frontend`, `data analyst`, `product manager`.

#### `location`

Optional free-text location keyword.

Examples: `Europe`, `Canada`, `United States`, `Worldwide`.

#### `country`

Optional country path.

Examples: `united-states`, `canada`, `united-kingdom`.

#### `category`

Optional category or skill path.

Examples: `engineering`, `sales`, `marketing-advertising-pr`, `project-management`.

#### `seniority`

Optional seniority path.

Examples: `entry-level`, `mid-level`, `senior`, `manager`, `director`, `executive`.

#### `jobType`

Optional job type path.

Examples: `full-time`, `part-time`, `contractor`.

#### `maxItems`

Maximum number of jobs to save.

Start with 25 for a smoke test.

#### `includeDetails`

Enable this to include description text, salary details, company URLs, and posting dates.

Disable it only when you need a fast URL-only discovery run.

### Output example

```json
{
  "title": "Preconstruction Project Coordinator | South Africa",
  "companyName": "HireHawk",
  "companyUrl": "https://himalayas.app/companies/hirehawk",
  "jobUrl": "https://himalayas.app/companies/hirehawk/jobs/preconstruction-project-coordinator-south-africa",
  "location": "South Africa",
  "salaryText": "USD 1600 - 2000 / month",
  "salaryMin": 1600,
  "salaryMax": 2000,
  "salaryCurrency": "USD",
  "salaryPeriod": "MONTH",
  "employmentType": "Contractor",
  "postedAt": "2026-07-06T08:12:46.000Z",
  "applyUrl": "https://himalayas.app/companies/hirehawk/jobs/preconstruction-project-coordinator-south-africa"
}
```

### Tips for best results

Use a narrow search query when you want highly relevant listings.

Use a category path when you want broad coverage in one job family.

Use `maxItems` to control run size and cost.

Schedule the actor daily if you monitor new openings.

Export to CSV when sharing with recruiting or sales teams.

Use JSON when sending results into an internal pipeline.

### Common use cases

Track remote engineering jobs.

Monitor hiring by companies in a target market.

Build a salary benchmark for remote roles.

Find companies hiring remote sales teams.

Create a daily new-postings alert.

Enrich CRM accounts with active hiring signals.

Analyze which countries receive the most remote roles.

### Integrations

Send new jobs to Slack using Apify webhooks.

Export datasets to Google Sheets with Make or Zapier.

Load job records into Airtable for recruiting operations.

Send company hiring signals to HubSpot or Salesforce.

Store historical runs in BigQuery, Snowflake, or PostgreSQL.

Trigger downstream enrichment actors after each run.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/himalayas-remote-jobs-scraper').call({
  searchQuery: 'sales',
  maxItems: 25,
  includeDetails: true,
});

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('fetch_cat/himalayas-remote-jobs-scraper').call(run_input={
    'searchQuery': 'sales',
    'maxItems': 25,
    'includeDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~himalayas-remote-jobs-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchQuery":"sales","maxItems":25,"includeDetails":true}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or any MCP-compatible client through the Apify MCP server.

MCP URL format:

```text
https://mcp.apify.com/?tools=fetch_cat/himalayas-remote-jobs-scraper
```

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=fetch_cat/himalayas-remote-jobs-scraper
```

Claude Desktop JSON config:

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

Example prompts:

- "Find 25 remote sales jobs on Himalayas and summarize salary ranges."
- "Scrape remote engineering jobs and group them by company."
- "Collect 50 customer support jobs and export the dataset as CSV."

### Scheduling

You can schedule this actor to run every day, every week, or at a custom interval.

Scheduling is useful when you monitor fresh job postings.

Use a stable search query and compare new dataset rows between runs.

### Data quality notes

Some job pages do not publish salary data.

Some jobs are restricted to a specific country.

Some jobs may expire after the actor collects them.

The actor returns null for fields that are not publicly available.

### FAQ

#### Can I scrape Himalayas remote jobs without an account?

Yes. This actor collects public job listing and job detail data visible on Himalayas without logging in.

#### Can I filter by country or category?

Yes. Use `country`, `category`, `searchQuery`, or direct `startUrls` to target the jobs you need.

### Troubleshooting

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

The selected query or filter may have fewer public results available at run time.

Try a broader query or remove a restrictive filter.

#### Why is salary missing for some jobs?

Not every Himalayas listing publishes salary data.

When salary is absent, the salary fields are returned as null.

#### Why does `applyUrl` point to Himalayas?

Himalayas sometimes routes applications through its own job detail page.

The job URL is still the correct public page for the opening.

### Limits

This actor only extracts public information available without logging in.

It does not apply to jobs for you.

It does not bypass access controls.

It does not guarantee that a job remains open after scraping.

### Legality and responsible use

This actor is intended for publicly available job listing data.

Respect Himalayas.app terms, applicable laws, and personal data rules in your jurisdiction.

Avoid collecting or storing data you do not need.

Use reasonable run sizes and schedules.

### Related scrapers

- [Google Maps Lead Finder](https://apify.com/fetch_cat/google-maps-lead-finder) — collect local business leads and company contact signals.
- [LinkedIn Company Profile Scraper](https://apify.com/fetch_cat/linkedin-company-profile-scraper) — enrich companies found through job listings.
- [Indeed Scraper](https://apify.com/fetch_cat/indeed-scraper) — compare hiring demand across another job source.

Use related actors together to compare remote hiring demand across multiple sources.

### Support

If a run fails or output looks incomplete, include:

- The input JSON you used.
- The expected output, such as the job title or company you expected to see.
- The actual output you received, including an empty dataset if applicable.
- A reproducible public URL from Himalayas, when your report is about a specific search or job page.
- The Apify run ID and any relevant log message.

Small reproducible inputs make issues easier to diagnose.

# Actor input Schema

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

Optional Himalayas job search, category, country, or company job URLs to crawl. Leave empty to use the search filters below.

## `searchQuery` (type: `string`):

Keyword to search on Himalayas, such as sales, react, support, data analyst, or product manager.

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

Optional location keyword to combine with the search query, such as Europe, United States, Canada, or Worldwide.

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

Optional country filter path value. Example: united-states, canada, united-kingdom. Used when no category is provided.

## `category` (type: `string`):

Optional Himalayas category/skill path, such as engineering, sales, marketing-advertising-pr, customer-support, or project-management.

## `seniority` (type: `string`):

Optional seniority path, such as entry-level, mid-level, senior, manager, director, or executive. Used when category/country are empty.

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

Optional job type path, such as full-time, part-time, or contractor. Used when category/country/seniority are empty.

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

Maximum number of job records to save.

## `includeDetails` (type: `boolean`):

Fetch each public job detail page to include salary fields, description text, company URL, dates, seniority, and tags.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://himalayas.app/jobs?search=sales"
    }
  ],
  "searchQuery": "sales",
  "maxItems": 20,
  "includeDetails": true
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://himalayas.app/jobs?search=sales"
        }
    ],
    "searchQuery": "sales",
    "maxItems": 20,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/himalayas-remote-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://himalayas.app/jobs?search=sales" }],
    "searchQuery": "sales",
    "maxItems": 20,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/himalayas-remote-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://himalayas.app/jobs?search=sales"
    }
  ],
  "searchQuery": "sales",
  "maxItems": 20,
  "includeDetails": true
}' |
apify call fetch_cat/himalayas-remote-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Himalayas Remote Jobs Scraper",
        "description": "Scrape public Himalayas remote job listings with companies, salaries, locations, tags, descriptions, and application links.",
        "version": "0.1",
        "x-build-id": "s45FdmXvHOXtbiff1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~himalayas-remote-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-himalayas-remote-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/fetch_cat~himalayas-remote-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-himalayas-remote-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/fetch_cat~himalayas-remote-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-himalayas-remote-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": [
                    "maxItems"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional Himalayas job search, category, country, or company job URLs to crawl. Leave empty to use the search filters below.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword to search on Himalayas, such as sales, react, support, data analyst, or product manager."
                    },
                    "location": {
                        "title": "Location keyword",
                        "type": "string",
                        "description": "Optional location keyword to combine with the search query, such as Europe, United States, Canada, or Worldwide."
                    },
                    "country": {
                        "title": "Country path",
                        "type": "string",
                        "description": "Optional country filter path value. Example: united-states, canada, united-kingdom. Used when no category is provided."
                    },
                    "category": {
                        "title": "Category or skill path",
                        "type": "string",
                        "description": "Optional Himalayas category/skill path, such as engineering, sales, marketing-advertising-pr, customer-support, or project-management."
                    },
                    "seniority": {
                        "title": "Seniority path",
                        "type": "string",
                        "description": "Optional seniority path, such as entry-level, mid-level, senior, manager, director, or executive. Used when category/country are empty."
                    },
                    "jobType": {
                        "title": "Job type path",
                        "type": "string",
                        "description": "Optional job type path, such as full-time, part-time, or contractor. Used when category/country/seniority are empty."
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job records to save.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Include full job details",
                        "type": "boolean",
                        "description": "Fetch each public job detail page to include salary fields, description text, company URL, dates, seniority, and tags.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
