# Welcome to the Jungle Jobs Scraper (Pay-Per-Event) (`prodiger/welcome-to-the-jungle-jobs-scraper`) Actor

Search and scrape Welcome to the Jungle job listings by keyword, location, contract, remote policy, language, and market. Optionally enrich each result with descriptions, salary, skills, benefits, recruitment details, and company data. Built and operated with permission from Welcome to the Jungle.

- **URL**: https://apify.com/prodiger/welcome-to-the-jungle-jobs-scraper.md
- **Developed by:** [Arnas](https://apify.com/prodiger) (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.50 / 1,000 job scrapeds

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

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

## What's an Apify Actor?

Actors are 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

**Welcome to the Jungle Jobs Scraper** turns job search results into structured data for recruiting, labor-market research, competitive intelligence, and workflow automation. Search by keyword and location, apply contract, remote-policy, language, country, and regional-market filters, then optionally enrich every result with its full description, candidate profile, recruitment process, salary, skills, tools, benefits, application link, offices, and company data.

**Authorization:** this Actor is built and operated with permission from Welcome to the Jungle. That authorization does not imply endorsement. Runs must remain within the authorization’s scope and applicable privacy, employment, and data-use law.

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

The Actor queries Welcome to the Jungle’s public job-search service, follows result pages, deduplicates jobs by their stable job reference, and writes one dataset row per unique listing. Different search-index variants of the same job are emitted and charged only once. With detail enrichment enabled, it also calls the public job-detail endpoint and merges the richer response into the same row. If a detail record has disappeared or temporarily fails, the searchable listing is still emitted and the diagnostic is saved separately in the run’s **Diagnostics** output.

This is a lightweight HTTP Actor: it does not launch a browser, log into an account, or require users to supply cookies. Requests are throttled to no more than four starts per second and transient failures use bounded backoff.

### Why use Welcome to the Jungle Jobs Scraper?

- Monitor which roles and skills companies are hiring for.
- Build recruiting or candidate-discovery feeds by city, country, contract, or remote policy.
- Compare salary disclosure, benefits, tools, and job-description language.
- Track company hiring activity without manually paging through search results.
- Export clean JSON, CSV, Excel, XML, or HTML from an Apify dataset.
- Schedule recurring runs or connect results to webhooks and other Apify integrations.
- Resume from checkpointed pages and reconcile stable IDs already present in the run dataset.

### How to use Welcome to the Jungle Jobs Scraper

1. Enter a search query such as `software engineer`, `product designer`, or `data`.
2. Optionally enter a location or two-letter country code.
3. Choose contract, remote-policy, listing-language, and regional-market filters.
4. Set the number of jobs, up to 1,000.
5. Keep full job details enabled for the richest records, or disable it for faster search-only output.
6. Start the run and open the Dataset tab to inspect or export results.

### Input

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `searchQuery` | string | `software engineer` | Keyword, title, skill, or company; an explicit empty string searches all jobs |
| `location` | string | empty | City, district, state, or country |
| `countryCode` | string | empty | ISO alpha-2 country code such as `FR` or `GB` |
| `maxJobs` | integer | `50` | Maximum unique rows, from 1 to 1,000 |
| `contractType` | string | `all` | Full-time, part-time, internship, apprenticeship, freelance, and more |
| `remote` | string | `all` | Fully remote, partial/hybrid, occasional, on-site, or unspecified |
| `language` | string | `all` | English, French, Spanish, Czech, or Slovak |
| `market` | string | `all` | Optional Welcome to the Jungle regional market |
| `scrapeJobDetails` | boolean | `true` | Enrich each listing with its full job and company record |
| `maxRequestRetries` | integer | `3` | Additional attempts for rate limits, server errors, and network failures |
| `proxyConfiguration` | object | disabled | Optional Apify or custom proxy configuration |

Example:

```json
{
    "searchQuery": "backend engineer",
    "location": "Paris",
    "countryCode": "FR",
    "maxJobs": 100,
    "contractType": "FULL_TIME",
    "remote": "partial",
    "language": "fr",
    "scrapeJobDetails": true
}
````

### Output

Each unique job is one dataset item. Detail-only values are `null` or empty arrays when enrichment is disabled or the source does not publish them.

```json
{
    "id": "EXAMPLE_a1B2c3D4",
    "title": "Software Engineer",
    "url": "https://www.welcometothejungle.com/fr/companies/example/jobs/software-engineer",
    "applyUrl": "https://www.welcometothejungle.com/fr/companies/example/jobs/software-engineer",
    "language": "fr",
    "companyName": "Example",
    "location": "Paris, France",
    "contractType": "FULL_TIME",
    "contractTypeLabel": "CDI",
    "remote": "partial",
    "remoteLabel": "Hybrid / a few days at home",
    "salaryMin": 50000,
    "salaryMax": 65000,
    "salaryCurrency": "EUR",
    "descriptionText": "Join the engineering team...",
    "skills": ["TypeScript", "Node.js"],
    "benefits": ["Remote work", "Meal vouchers"],
    "searchQuery": "backend engineer",
    "searchLocation": "Paris",
    "scrapedAt": "2026-07-27T18:00:00.000Z"
}
```

#### Main data fields

| Group | Fields |
|---|---|
| Identity | `id`, `reference`, `wttjReference`, `title`, `url`, `applyUrl`, `language` |
| Dates | `publishedAt`, `updatedAt`, `startDate`, `scrapedAt` |
| Company | `companyName`, `companyUrl`, `companyLogo`, `companyWebsite`, `companyLinkedinUrl`, employee and job counts, company description |
| Location | `location`, `city`, `district`, `state`, `country`, `countryCode`, `address`, coordinates, `offices` |
| Employment | contract type and duration, remote policy, salary range/currency/period, experience, education, department, profession |
| Content | summary, description HTML/text, candidate profile, key missions, recruitment process |
| Taxonomy | sectors, sector categories, skills, tools, benefits |
| Provenance | `searchQuery`, `searchLocation` |

#### Diagnostics

Recoverable detail and output errors do not pollute the jobs dataset. They are appended to the run’s **Diagnostics** key-value-store collection in JSONL batches named `DIAGNOSTICS-000001.jsonl`, `DIAGNOSTICS-000002.jsonl`, and so on. Each row includes `recordedAt`; batches contain at most 100 rows and are flushed on completion, failure, abort, and platform migration.

### How much does it cost?

This Actor uses pay-per-event pricing:

| Event | Price | When charged |
|---|---:|---|
| Actor start | $0.00005 | Automatically when the run starts; includes the first five seconds of platform compute |
| Job scraped | $0.0005 | After a unique job row is successfully written |

A 50-job run costs **$0.02505**; a 1,000-job run costs **$0.50005**. Failed fetches and failed dataset writes are not billed as jobs. Platform usage is included in the event prices.

The Apify SDK appends each row and then charges its paired event; that append, the charge, and the crawl checkpoint are not one atomic transaction. On startup, the Actor reconciles stable IDs already in the default dataset and does not write or charge them again. If a combined append/charge response is lost after the row became durable, the Actor records a billing diagnostic and favors avoiding a possible double charge; that rare row can therefore be undercharged. Dataset visibility during an abrupt platform interruption is also eventually consistent, so exactly-once delivery is not claimed.

### Tips and advanced options

- Turn off `scrapeJobDetails` when titles, companies, locations, and listing metadata are enough. This removes one request per job.
- Use `countryCode` for precise country filtering and `location` for city or regional matching.
- The public Algolia search index exposes at most **1,000 reachable hits per filtered search**. Split broad collection work by country, market, contract, or keyword.
- Anonymous search credentials and the index name can be overridden by the operator with `WTTJ_ALGOLIA_APP_ID`, `WTTJ_ALGOLIA_API_KEY`, and `WTTJ_ALGOLIA_INDEX` if Welcome to the Jungle rotates them.

### FAQ, limitations, and support

**Does it require a Welcome to the Jungle account?** No. It uses public search and job-detail endpoints without authentication.

**Why are some fields null?** Employers do not publish every field, and some attributes exist only on the detail endpoint. A detail failure deliberately falls back to search data.

**Why did I receive fewer than 1,000 jobs?** Filters may match fewer results, listings can overlap or disappear, and the public search service caps reachable results.

**Can I publish or resell the data?** Permission for operating this Actor is not blanket permission for every downstream use. Keep use within the granted authorization and applicable law.

**Is this an official Welcome to the Jungle product?** No endorsement or official affiliation is claimed.

For extraction problems, include a sanitized input, run ID, and one affected public job URL in an issue on the Actor’s **Issues** tab. Do not attach private authorization documents or personal data.

# Actor input Schema

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

Job title, skill, keyword, or company. Leave empty to browse all matching jobs.

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

City, district, state, or country, for example `Paris`, `London`, or `France`. Leave empty for all locations.

## `countryCode` (type: `string`):

Optional two-letter ISO country code such as `FR`, `GB`, or `US`. This can be combined with Location.

## `maxJobs` (type: `integer`):

Maximum unique jobs to write. The public search service exposes at most 1,000 hits for one filtered search.

## `contractType` (type: `string`):

Return only jobs with this contract type.

## `remote` (type: `string`):

Filter by the remote-work policy published with the job.

## `language` (type: `string`):

Filter by the job listing language.

## `market` (type: `string`):

Optionally restrict results to one Welcome to the Jungle regional website.

## `scrapeJobDetails` (type: `boolean`):

Fetch each job endpoint for descriptions, salary, skills, tools, benefits, recruitment process, application URL, and company details. Disable for faster listing-only runs.

## `maxRequestRetries` (type: `integer`):

Additional attempts after a rate limit, server error, or network failure. Requests are throttled to at most four starts per second.

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

Optional Apify Proxy or custom proxy settings. Direct requests are used by default because the authorized public endpoints do not require a proxy.

## Actor input object example

```json
{
  "searchQuery": "software engineer",
  "location": "Paris",
  "countryCode": "",
  "maxJobs": 50,
  "contractType": "all",
  "remote": "all",
  "language": "all",
  "market": "all",
  "scrapeJobDetails": true,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Scraped job listings — one row per unique job.

## `diagnostics` (type: `string`):

Append-only JSONL batches for recoverable errors, grouped in the run's Diagnostics key-value-store collection.

# 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 = {
    "searchQuery": "software engineer",
    "location": "Paris",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("prodiger/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 = {
    "searchQuery": "software engineer",
    "location": "Paris",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("prodiger/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 '{
  "searchQuery": "software engineer",
  "location": "Paris",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call prodiger/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=prodiger/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 Scraper (Pay-Per-Event)",
        "description": "Search and scrape Welcome to the Jungle job listings by keyword, location, contract, remote policy, language, and market. Optionally enrich each result with descriptions, salary, skills, benefits, recruitment details, and company data. Built and operated with permission from Welcome to the Jungle.",
        "version": "0.1",
        "x-build-id": "ZdbvgyT968PHIx0bP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/prodiger~welcome-to-the-jungle-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-prodiger-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/prodiger~welcome-to-the-jungle-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-prodiger-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/prodiger~welcome-to-the-jungle-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-prodiger-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",
                "properties": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Job title, skill, keyword, or company. Leave empty to browse all matching jobs.",
                        "default": "software engineer"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, district, state, or country, for example `Paris`, `London`, or `France`. Leave empty for all locations.",
                        "default": ""
                    },
                    "countryCode": {
                        "title": "Country code",
                        "pattern": "^$|^[A-Za-z]{2}$",
                        "type": "string",
                        "description": "Optional two-letter ISO country code such as `FR`, `GB`, or `US`. This can be combined with Location.",
                        "default": ""
                    },
                    "maxJobs": {
                        "title": "Max jobs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum unique jobs to write. The public search service exposes at most 1,000 hits for one filtered search.",
                        "default": 50
                    },
                    "contractType": {
                        "title": "Contract type",
                        "enum": [
                            "all",
                            "FULL_TIME",
                            "PART_TIME",
                            "TEMPORARY",
                            "INTERNSHIP",
                            "APPRENTICESHIP",
                            "FREELANCE",
                            "VIE",
                            "GRADUATE_PROGRAM",
                            "VOLUNTEER",
                            "OTHER"
                        ],
                        "type": "string",
                        "description": "Return only jobs with this contract type.",
                        "default": "all"
                    },
                    "remote": {
                        "title": "Remote policy",
                        "enum": [
                            "all",
                            "unknown",
                            "partial",
                            "fulltime",
                            "punctual",
                            "no"
                        ],
                        "type": "string",
                        "description": "Filter by the remote-work policy published with the job.",
                        "default": "all"
                    },
                    "language": {
                        "title": "Listing language",
                        "enum": [
                            "all",
                            "en",
                            "fr",
                            "es",
                            "cs",
                            "sk"
                        ],
                        "type": "string",
                        "description": "Filter by the job listing language.",
                        "default": "all"
                    },
                    "market": {
                        "title": "Welcome to the Jungle market",
                        "enum": [
                            "all",
                            "wttj_fr",
                            "wttj_us",
                            "wttj_gb",
                            "wttj_es",
                            "wttj_cs",
                            "wttj_sk"
                        ],
                        "type": "string",
                        "description": "Optionally restrict results to one Welcome to the Jungle regional website.",
                        "default": "all"
                    },
                    "scrapeJobDetails": {
                        "title": "Scrape full job details",
                        "type": "boolean",
                        "description": "Fetch each job endpoint for descriptions, salary, skills, tools, benefits, recruitment process, application URL, and company details. Disable for faster listing-only runs.",
                        "default": true
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Additional attempts after a rate limit, server error, or network failure. Requests are throttled to at most four starts per second.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy or custom proxy settings. Direct requests are used by default because the authorized public endpoints do not require a proxy.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
