# Welcome to the Jungle Jobs: JSON/RAG Scraper (`getascraper/welcome-to-the-jungle-jobs-scraper`) Actor

Scrape Welcome to the Jungle job listings with salary and location data across 50+ countries. Raw JSON or RAG-ready chunks. $3.99 per 1K jobs.

- **URL**: https://apify.com/getascraper/welcome-to-the-jungle-jobs-scraper.md
- **Developed by:** [GetAScraper](https://apify.com/getascraper) (community)
- **Categories:** Jobs, Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 60.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 jobs

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

## WTTJ Jobs Scraper: Raw JSON or RAG-Ready Chunks

**Extract job listings from Welcome to the Jungle with two output modes: raw JSON or RAG-ready chunks.** Get salary ranges, company data, locations, contract type, and remote policy across France, UK, US, Germany, and 50+ countries. Drop raw output into spreadsheets or pipelines. Use RAG-ready chunks directly in Qdrant, Pinecone, Weaviate, LangChain, or LlamaIndex for AI-powered job matching and resume screening.

### What does Welcome to the Jungle Scraper do?

This Actor queries WTTJ's public Algolia search API to extract structured job data. It supports two output modes:

1. **Raw JSON** - Full job listings with title, company, salary, locations, contract type, remote policy, summary, and sectors. Ready for spreadsheets, CRMs, or data warehouses.

2. **RAG-Ready** - Job descriptions tokenized into fixed-size chunks using tiktoken cl100k_base. Configurable chunk size (default 512 tokens) with overlap. Drop straight into any vector database for LLM-based job matching, resume screening, or market intelligence.

The scraper covers 10,000+ companies across Europe and the US. No login, no API key, no proxy required.

### Why use Welcome to the Jungle Scraper for RAG?

- **Dual output modes.** Raw JSON for traditional pipelines, RAG-ready chunks for AI agents and vector databases. One Actor handles both workflows.
- **RAG-ready chunks.** Job descriptions pre-split for LLM ingestion. No LaTeX stripping, no HTML parsing, no custom chunking logic on your side. Works with Qdrant, Pinecone, Weaviate, pgvector, and Chroma.
- **Framework-ready.** Raw output drops into Google Sheets, BigQuery, n8n, or any CRM. RAG chunks drop into LangChain, LlamaIndex, Haystack, or custom LLM pipelines.
- **Europe plus US coverage.** France, UK, Germany, Spain, and 50+ countries in one query. Compare salary ranges across markets.
- **Rich job metadata.** Salary ranges (EUR, GBP, USD), remote policy, contract type, experience level, company size, and hiring velocity.
- **No auth required.** Uses WTTJ's public Algolia API. No cookies, no API key, no account.

### How to use Welcome to the Jungle Scraper

1. Open the Actor in Apify Console.
2. Set a search query (e.g., `data engineer`, `product manager`, `sales`).
3. Choose output mode: `raw` for standard JSON, `rag` for chunked text.
4. Optional: Add filters for country, city, contract type, remote policy.
5. Set max results (default 100, max 10,000).
6. Click Start. Download as JSON, CSV, or Excel.

### Input

| Field | Type | Description |
|---|---|---|
| `query` | string | Job title, skill, or keyword to search (required). |
| `locale` | string | Language: `en` or `fr`. Default: `en`. |
| `countryCodes` | array | Filter by country codes (e.g., `FR`, `GB`, `US`). |
| `locations` | array | Filter by city or region (e.g., `Paris`, `London`). |
| `contractTypes` | array | Filter by contract type (`FULL_TIME`, `PART_TIME`, `INTERNSHIP`, `FREELANCE`). |
| `remotePolicies` | array | Filter by remote policy (`full`, `partial`, `punctual`, `no`). |
| `categories` | array | Filter by job category (`tech`, `data`, `sales`, `marketing`). |
| `maxItems` | integer | Maximum jobs to return. Default: 100. Max: 10,000. |
| `outputMode` | string | `raw` (full JSON) or `rag` (chunked text). Default: `raw`. |
| `chunkSize` | integer | Target tokens per chunk for RAG mode. Default: 512. |
| `chunkOverlap` | integer | Token overlap between chunks for RAG mode. Default: 50. |

### Output

#### Raw Mode Example

```json
{
    "jobId": "2d4fbe25-352d-47a4-8280-bd6d4642cfb1",
    "title": "Data analytics engineer",
    "company": {
        "name": "Visian",
        "slug": "visian",
        "size": "50-249 employees",
        "employeeCount": 200,
        "description": "Consulting et execution technique pour projets data."
    },
    "locations": [
        { "city": "Courbevoie", "country": "France", "countryCode": "FR", "region": "Ile-de-France" }
    ],
    "primaryLocation": "Courbevoie, France",
    "contractType": "full_time",
    "remotePolicy": "partial",
    "salary": {
        "hasSalary": true,
        "min": 42000,
        "max": 55000,
        "yearlyMinimum": 42000,
        "currency": "EUR",
        "period": "yearly"
    },
    "publishedAt": "2026-06-04T09:39:54Z",
    "summary": "Rejoignez Visian, une societe de conseil specialisee en innovation...",
    "sectors": ["Artificial Intelligence / Machine Learning", "IT / Digital"],
    "url": "https://www.welcometothejungle.com/en/jobs/data-engineer-visian-xxx",
    "scrapedAt": "2026-06-06T10:00:00.000Z"
}
````

#### RAG Mode Example

```json
{
    "jobId": "2d4fbe25-352d-47a4-8280-bd6d4642cfb1",
    "title": "Data analytics engineer",
    "company": { "name": "Visian", "slug": "visian" },
    "primaryLocation": "Courbevoie, France",
    "chunks": [
        { "idx": 0, "text": "Job Title: Data analytics engineer\nCompany: Visian\nLocation: Courbevoie, France\n\nRejoignez Visian...", "tokens": 256 },
        { "idx": 1, "text": "...SQL, Databricks, Git et Power BI...", "tokens": 128 }
    ],
    "scrapedAt": "2026-06-06T10:00:00.000Z"
}
```

### Data Table

| Field | Description |
|---|---|
| `jobId` | WTTJ unique job identifier. |
| `title` | Job title as posted. |
| `company.name` | Hiring company name. |
| `company.slug` | Company URL slug. |
| `company.size` | Company size category (e.g., "50-249 employees"). |
| `company.employeeCount` | Total employees when available. |
| `locations` | Array of location objects with city, country, countryCode, region. |
| `primaryLocation` | Primary location as formatted string. |
| `contractType` | Contract type enum (full\_time, part\_time, internship, freelance). |
| `remotePolicy` | Remote work policy (full, partial, punctual, no, unknown). |
| `salary` | Salary object with min, max, currency, period when disclosed. |
| `publishedAt` | ISO date of job posting. |
| `summary` | Short job summary or description. |
| `sectors` | Array of job category sectors. |
| `url` | Canonical job URL on welcometothejungle.com. |
| `chunks` | RAG mode only: array of `{ idx, text, tokens }` chunks. |
| `scrapedAt` | ISO timestamp of scrape. |

### Pricing

**$3.99 per 1,000 job listings** (pay-per-result).

| Volume | Estimated cost |
|---|---|
| 100 jobs | **$0.40** |
| 1,000 jobs | **$3.99** |
| 10,000 jobs | **$39.90** |

No subscription. No minimum. You pay only for successful records.

### Tips

- **Use RAG mode for AI agents.** Feed chunks directly into a vector database for job matching, resume screening, or market intelligence. Compatible with LangChain, LlamaIndex, Qdrant, Pinecone, and Weaviate.
- **Filter by country first.** WTTJ has different job densities per market. France and UK have the most listings.
- **Combine with salary filters.** Many jobs disclose salary ranges. Filter `salary.hasSalary: true` downstream for benchmarking.
- **Schedule weekly for market tracking.** Compare job counts and salary ranges over time to detect hiring trend shifts.

### FAQ, Disclaimers, and Support

**Is scraping Welcome to the Jungle legal?** This Actor uses WTTJ's public Algolia search API, which requires no authentication. It collects publicly visible job listing data for research, market analysis, and recruiting intelligence. Users are responsible for ensuring their use complies with applicable laws and WTTJ's terms of service.

**Why are some salary fields empty?** Many jobs on WTTJ do not disclose salary. The Actor only saves salary values that the source exposes. Filter `salary.hasSalary: true` downstream if salary data is critical.

**What is RAG mode?** RAG (Retrieval-Augmented Generation) mode splits job descriptions into fixed-token chunks using tiktoken cl100k\_base encoding. These chunks are ready to embed and store in a vector database for LLM-based job matching or resume screening.

**How is this different from other WTTJ scrapers?** This is the only WTTJ scraper with dual output modes: raw JSON for traditional pipelines and RAG-ready chunks for AI agents. No other scraper offers tiktoken-based chunking optimized for LLM ingestion.

**Support:** Open an issue on the Actor's Issues tab in Apify Console for bug reports, feature requests, or custom-run quotes.

***

**Built with Apify + Crawlee + TypeScript.** Part of the [actorstack](https://github.com/devanshtiwari/actorstack) portfolio.

# Actor input Schema

## `query` (type: `string`):

Job title, skill, company, or keyword to search for.

## `locale` (type: `string`):

Language for search results and job descriptions.

## `countryCodes` (type: `array`):

Filter by country codes (e.g., FR, GB, US, DE). Leave empty for all.

## `locations` (type: `array`):

Filter by city or region (e.g., Paris, London). Leave empty for all.

## `contractTypes` (type: `array`):

Filter by contract type. Options: FULL\_TIME, PART\_TIME, INTERNSHIP, FREELANCE, APPRENTICESHIP

## `remotePolicies` (type: `array`):

Filter by remote work policy. Options: full, partial, punctual, no

## `categories` (type: `array`):

Filter by job category (e.g., tech, data, sales, marketing).

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

Maximum number of job listings to save per run.

## `includeJobDetails` (type: `boolean`):

Fetch full job descriptions, apply URLs, and benefits when available. Slower but richer data.

## `outputMode` (type: `string`):

Choose between raw JSON or RAG-ready chunked output.

## `chunkSize` (type: `integer`):

Target tokens per chunk for RAG output. Uses tiktoken cl100k\_base.

## `chunkOverlap` (type: `integer`):

Token overlap between consecutive chunks for RAG output.

## `proxyConfiguration` (type: `object`):

Proxy settings for the crawler.

## Actor input object example

```json
{
  "query": "data",
  "locale": "en",
  "countryCodes": [],
  "locations": [],
  "contractTypes": [],
  "remotePolicies": [],
  "categories": [],
  "maxItems": 100,
  "includeJobDetails": false,
  "outputMode": "raw",
  "chunkSize": 512,
  "chunkOverlap": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "query": "data",
    "locale": "en",
    "countryCodes": [],
    "locations": [],
    "contractTypes": [],
    "remotePolicies": [],
    "categories": [],
    "maxItems": 100,
    "includeJobDetails": false,
    "outputMode": "raw",
    "chunkSize": 512,
    "chunkOverlap": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/welcome-to-the-jungle-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 = {
    "query": "data",
    "locale": "en",
    "countryCodes": [],
    "locations": [],
    "contractTypes": [],
    "remotePolicies": [],
    "categories": [],
    "maxItems": 100,
    "includeJobDetails": False,
    "outputMode": "raw",
    "chunkSize": 512,
    "chunkOverlap": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/welcome-to-the-jungle-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 '{
  "query": "data",
  "locale": "en",
  "countryCodes": [],
  "locations": [],
  "contractTypes": [],
  "remotePolicies": [],
  "categories": [],
  "maxItems": 100,
  "includeJobDetails": false,
  "outputMode": "raw",
  "chunkSize": 512,
  "chunkOverlap": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call getascraper/welcome-to-the-jungle-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Welcome to the Jungle Jobs: JSON/RAG Scraper",
        "description": "Scrape Welcome to the Jungle job listings with salary and location data across 50+ countries. Raw JSON or RAG-ready chunks. $3.99 per 1K jobs.",
        "version": "0.1",
        "x-build-id": "2lAJ5GVk2xJTaMgdx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~welcome-to-the-jungle-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-welcome-to-the-jungle-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/getascraper~welcome-to-the-jungle-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-welcome-to-the-jungle-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/getascraper~welcome-to-the-jungle-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-welcome-to-the-jungle-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": [
                    "query",
                    "maxItems",
                    "outputMode"
                ],
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Job title, skill, company, or keyword to search for.",
                        "default": "data"
                    },
                    "locale": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "fr"
                        ],
                        "type": "string",
                        "description": "Language for search results and job descriptions.",
                        "default": "en"
                    },
                    "countryCodes": {
                        "title": "Country Filters",
                        "type": "array",
                        "description": "Filter by country codes (e.g., FR, GB, US, DE). Leave empty for all.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "locations": {
                        "title": "City/Region Filters",
                        "type": "array",
                        "description": "Filter by city or region (e.g., Paris, London). Leave empty for all.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "contractTypes": {
                        "title": "Contract Type Filters",
                        "type": "array",
                        "description": "Filter by contract type. Options: FULL_TIME, PART_TIME, INTERNSHIP, FREELANCE, APPRENTICESHIP",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "remotePolicies": {
                        "title": "Remote Policy Filters",
                        "type": "array",
                        "description": "Filter by remote work policy. Options: full, partial, punctual, no",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "categories": {
                        "title": "Job Category Filters",
                        "type": "array",
                        "description": "Filter by job category (e.g., tech, data, sales, marketing).",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxItems": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job listings to save per run.",
                        "default": 100
                    },
                    "includeJobDetails": {
                        "title": "Include Full Job Details",
                        "type": "boolean",
                        "description": "Fetch full job descriptions, apply URLs, and benefits when available. Slower but richer data.",
                        "default": false
                    },
                    "outputMode": {
                        "title": "Output Mode",
                        "enum": [
                            "raw",
                            "rag"
                        ],
                        "type": "string",
                        "description": "Choose between raw JSON or RAG-ready chunked output.",
                        "default": "raw"
                    },
                    "chunkSize": {
                        "title": "Chunk Size (RAG mode only)",
                        "minimum": 128,
                        "maximum": 2048,
                        "type": "integer",
                        "description": "Target tokens per chunk for RAG output. Uses tiktoken cl100k_base.",
                        "default": 512
                    },
                    "chunkOverlap": {
                        "title": "Chunk Overlap (RAG mode only)",
                        "minimum": 0,
                        "maximum": 256,
                        "type": "integer",
                        "description": "Token overlap between consecutive chunks for RAG output.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the crawler.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
