# Welcome to the Jungle Jobs Scraper (`benthepythondev/welcome-to-the-jungle-jobs-scraper`) Actor

Scrape Welcome to the Jungle jobs with title, company, location, remote policy, salary, contract, description, application URL and company intelligence.

- **URL**: https://apify.com/benthepythondev/welcome-to-the-jungle-jobs-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Jobs, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 results

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

## Welcome to the Jungle Jobs Scraper

Collect current public job listings from **Welcome to the Jungle (WTTJ)** and turn them into structured recruitment and labor-market data. Search by role, technology, employer or keyword, narrow results by country, city, contract, remote policy and language, and optionally enrich every row from the public job page.

The Actor returns job titles, employers, locations, contract and remote-work metadata, salary fields, publication dates, company size and sector intelligence, descriptions, application links and canonical WTTJ URLs. Results can be exported as JSON, CSV, Excel or XML, scheduled in Apify, or consumed through the API.

### What can you use this Actor for?

- Monitor new technology, data, product, sales or operations vacancies.
- Build a structured feed for recruitment research or job-market analysis.
- Track which companies are hiring in a country, city, sector or remote-work segment.
- Compare contract types, disclosed salaries and hiring activity across markets.
- Find growing employers by combining job volume with company size and sector data.
- Power internal dashboards, alerts, spreadsheets, CRMs and data warehouses.
- Create recurring snapshots for trend analysis without manually browsing search pages.

### Why scrape Welcome to the Jungle?

Welcome to the Jungle combines job postings with unusually rich public employer profiles. A single search result can include the hiring company, employee count, company-size band, industries, office location, remote policy, contract type and publication time. When detail enrichment is enabled, the Actor also reads the public job page for the full description, application URL, validity date and street-level location metadata when those fields are published.

That combination is useful for more than job hunting. Recruiters can monitor target employers, market researchers can compare hiring patterns, sales teams can identify companies with active expansion signals, and analysts can build repeatable datasets instead of collecting listings manually.

### Input

The default run searches for `python`, fetches job-page details and saves up to 10 jobs. This small default keeps first runs fast and predictable.

| Field | Purpose |
|---|---|
| `queries` | Roles, employers, skills or free-text terms to search. |
| `locale` | Language used for WTTJ links and localized labels. |
| `countryCodes` | Optional ISO country filters such as `FR`, `GB`, `US` or `DE`. |
| `cities` | Optional exact city filters such as `Paris`, `London` or `Berlin`. |
| `contractTypes` | Filter permanent, temporary, internship, freelance and other contracts. |
| `remotePolicies` | Filter fully remote, hybrid, occasional remote, on-site or unknown. |
| `languages` | Filter the language of the published job content. |
| `searchTitleOnly` | Restrict the keyword match to job titles. |
| `postedWithinDays` | Keep jobs published within a recent time window; `0` means any age. |
| `includeDetails` | Fetch full descriptions, application URLs and job-page metadata. |
| `maxResultsPerQuery` | Maximum unique jobs saved for each query. |
| `maxPagesPerQuery` | Safety cap for source pagination. |

#### Example input

```json
{
  "queries": ["python", "data engineer"],
  "locale": "en",
  "countryCodes": ["FR", "GB"],
  "remotePolicies": ["fulltime", "partial"],
  "postedWithinDays": 14,
  "includeDetails": true,
  "maxResultsPerQuery": 25
}
````

Filters are applied at the source whenever WTTJ exposes them as searchable facets. Posting age is checked against each result's public timestamp. Duplicate jobs shared by multiple queries are saved only once.

### Output

Each dataset item is one public job listing. Common fields include:

- `reference`, `object_id`, `url`, `apply_url`
- `title`, `profile`, `description_text`, `description_html`, `qualifications`
- `published_at`, `date_posted`, `valid_through`, `language`, `market`
- `contract_type`, `contract_label`, `remote_policy`, `department`
- `experience_level_minimum`, `education_level`, `profession`, `profession_category`
- `salary_minimum`, `salary_maximum`, `salary_yearly_minimum`, `salary_currency`, `salary_period`
- `city`, `district`, `region`, `country`, `country_code`, `offices`
- `latitude`, `longitude`, `detail_locations`
- `company_name`, `company_url`, `company_website`, `company_description`
- `company_size`, `company_employee_count`, `company_logo`, `company_cover_image`
- `company_labels`, `sectors`, `is_promoted`
- `source_query`, `source_search_url`, `search_rank`, `scraped_at`

#### Example result

```json
{
  "reference": "PARTO_PqAo88l",
  "url": "https://www.welcometothejungle.com/en/companies/partoo/jobs/lead-developer-python-react-cdi-paris-m-f-d_paris",
  "title": "Lead Developer (Python/React) - CDI - Paris - M/F/D",
  "company_name": "Partoo",
  "company_employee_count": 330,
  "city": "Paris",
  "country": "France",
  "country_code": "FR",
  "contract_type": "FULL_TIME",
  "remote_policy": "partial",
  "published_at": "2026-07-10T15:00:00.000+02:00",
  "apply_url": "https://career.partoo.fr/jobs/...",
  "source_query": "python"
}
```

Fields remain `null` when the publisher did not disclose them. The Actor does not invent salaries, experience requirements, contact details or remote-work policies.

### Reliable extraction design

The Actor discovers WTTJ's current public search configuration at runtime and uses the same search-only index exposed to visitors by the website. Search pagination is handled with bounded requests and all records are deduplicated by the source job reference. Optional detail requests use browser-compatible HTTP fingerprints and parse structured JobPosting metadata from each public listing page.

Runs fail visibly when no usable records are returned. This prevents an empty dataset from looking like a healthy extraction. The default result limit is intentionally small, while higher limits remain available for production workflows.

### Scheduling and integrations

Use an Apify schedule to run the Actor hourly, daily or weekly. A useful monitoring pattern is to search a stable set of roles and countries, keep `postedWithinDays` narrow, and use `reference` as the external deduplication key. The dataset API can feed Make, Zapier, n8n, Google Sheets, a database or your own application.

For change detection, store the latest `reference` values or compare `published_at` between runs. For employer research, group rows by `company_name`, `company_employee_count`, `sectors` or `country_code`. For salary analysis, filter out rows without disclosed salary values rather than treating missing values as zero.

### Pricing

This Actor uses transparent pay-per-event pricing. A tiny start event covers run initialization, and each unique row pushed to the default dataset is charged as one `result` event. You are not charged for duplicate records that are discarded before output.

### Responsible use

The Actor collects public job and company information. Use the data for legitimate recruitment, research, monitoring and integration workflows. Respect applicable privacy, employment, marketing and database rules. Review a job's canonical WTTJ page before making decisions because listings can change or expire after collection.

### FAQ

#### Does this require a WTTJ login?

No. It reads public search and job-page information without a user account.

#### Can I search several roles in one run?

Yes. Add multiple values to `queries`. A job matching more than one query is returned once.

#### Why is a salary or application URL missing?

Not every employer publishes every field. Keep `includeDetails` enabled for the richest available output, but undisclosed values remain empty.

#### Can I collect only recent jobs?

Yes. Set `postedWithinDays` to a positive number such as `1`, `7`, `14` or `30`.

#### Can I search only job titles?

Yes. Enable `searchTitleOnly` to avoid matches that occur only in company or profile text.

#### How should I avoid duplicates across scheduled runs?

Use `reference` as the primary key and `url` as a fallback. Within each run, the Actor already deduplicates by the source reference.

#### What happens if WTTJ changes?

The Actor refreshes the public search configuration on every run and fails clearly when the source no longer returns usable data. Open an issue from the Actor page if a source change needs attention.

### You might also like

- [StepStone Scraper](https://apify.com/benthepythondev/stepstone-scraper) for European job-board listings.
- [Glassdoor Jobs Scraper](https://apify.com/benthepythondev/glassdoor-jobs-scraper) for employer and vacancy research.
- [Naukri Scraper](https://apify.com/benthepythondev/naukri-scraper) for India job-market data.
- [The Muse Jobs Scraper](https://apify.com/benthepythondev/themuse-jobs-scraper) for public job and company records.

If this Actor saves you time, please leave a review on its Apify Store page. Reviews help prioritize fixes and improvements. For a bug or feature request, open an issue with a small input example and the expected behavior.

**Keywords:** Welcome to the Jungle scraper, WTTJ jobs scraper, Welcome to the Jungle API, job listings API, Europe jobs data, France jobs scraper, remote jobs scraper, recruitment data, hiring intelligence, labor market analytics, company hiring signals, Apify jobs scraper

# Actor input Schema

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

Roles, skills, employers or keywords to search in public WTTJ jobs.

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

Language used for WTTJ URLs and localized company, sector and contract labels.

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

Optional two-letter country codes, for example FR, GB, US, DE or ES.

## `cities` (type: `array`):

Optional exact city names, for example Paris, London, Berlin or Prague.

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

Optional source-side contract filters.

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

Optional source-side remote-work filters.

## `languages` (type: `array`):

Optional language codes for the job posting content, for example en or fr.

## `searchTitleOnly` (type: `boolean`):

Match each query only against job titles instead of all searchable job fields.

## `postedWithinDays` (type: `integer`):

Keep jobs published within this many days. Use 0 for any posting age.

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

Fetch each public job page for the full description, application URL, validity date and street-level location fields.

## `maxResultsPerQuery` (type: `integer`):

Maximum unique job rows saved for each search query.

## `maxPagesPerQuery` (type: `integer`):

Safety cap for source pagination, especially when using posting-age filters.

## Actor input object example

```json
{
  "queries": [
    "python",
    "data engineer"
  ],
  "locale": "en",
  "countryCodes": [
    "FR"
  ],
  "cities": [
    "Paris"
  ],
  "contractTypes": [],
  "remotePolicies": [],
  "languages": [],
  "searchTitleOnly": false,
  "postedWithinDays": 0,
  "includeDetails": true,
  "maxResultsPerQuery": 10,
  "maxPagesPerQuery": 20
}
```

# 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 = {
    "queries": [
        "python",
        "data engineer"
    ],
    "locale": "en",
    "countryCodes": [
        "FR"
    ],
    "cities": [
        "Paris"
    ],
    "searchTitleOnly": false,
    "postedWithinDays": 0,
    "includeDetails": true,
    "maxResultsPerQuery": 10,
    "maxPagesPerQuery": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/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 = {
    "queries": [
        "python",
        "data engineer",
    ],
    "locale": "en",
    "countryCodes": ["FR"],
    "cities": ["Paris"],
    "searchTitleOnly": False,
    "postedWithinDays": 0,
    "includeDetails": True,
    "maxResultsPerQuery": 10,
    "maxPagesPerQuery": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/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 '{
  "queries": [
    "python",
    "data engineer"
  ],
  "locale": "en",
  "countryCodes": [
    "FR"
  ],
  "cities": [
    "Paris"
  ],
  "searchTitleOnly": false,
  "postedWithinDays": 0,
  "includeDetails": true,
  "maxResultsPerQuery": 10,
  "maxPagesPerQuery": 20
}' |
apify call benthepythondev/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=benthepythondev/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",
        "description": "Scrape Welcome to the Jungle jobs with title, company, location, remote policy, salary, contract, description, application URL and company intelligence.",
        "version": "1.0",
        "x-build-id": "JCfodmXfvEf8xBCdo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~welcome-to-the-jungle-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-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/benthepythondev~welcome-to-the-jungle-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-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/benthepythondev~welcome-to-the-jungle-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Job search queries",
                        "type": "array",
                        "description": "Roles, skills, employers or keywords to search in public WTTJ jobs.",
                        "default": [
                            "python"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locale": {
                        "title": "Output market",
                        "enum": [
                            "en",
                            "fr",
                            "es",
                            "cs",
                            "sk"
                        ],
                        "type": "string",
                        "description": "Language used for WTTJ URLs and localized company, sector and contract labels.",
                        "default": "en"
                    },
                    "countryCodes": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Optional two-letter country codes, for example FR, GB, US, DE or ES.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Optional exact city names, for example Paris, London, Berlin or Prague.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "contractTypes": {
                        "title": "Contract types",
                        "type": "array",
                        "description": "Optional source-side contract filters.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "FULL_TIME",
                                "TEMPORARY",
                                "INTERNSHIP",
                                "APPRENTICESHIP",
                                "FREELANCE",
                                "PART_TIME",
                                "VIE",
                                "OTHER"
                            ]
                        },
                        "default": []
                    },
                    "remotePolicies": {
                        "title": "Remote policies",
                        "type": "array",
                        "description": "Optional source-side remote-work filters.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "fulltime",
                                "partial",
                                "punctual",
                                "no",
                                "unknown"
                            ],
                            "enumTitles": [
                                "Fully remote",
                                "Hybrid",
                                "Occasional remote",
                                "On-site",
                                "Unknown"
                            ]
                        },
                        "default": []
                    },
                    "languages": {
                        "title": "Job languages",
                        "type": "array",
                        "description": "Optional language codes for the job posting content, for example en or fr.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTitleOnly": {
                        "title": "Search titles only",
                        "type": "boolean",
                        "description": "Match each query only against job titles instead of all searchable job fields.",
                        "default": false
                    },
                    "postedWithinDays": {
                        "title": "Maximum posting age",
                        "minimum": 0,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Keep jobs published within this many days. Use 0 for any posting age.",
                        "default": 0
                    },
                    "includeDetails": {
                        "title": "Fetch job-page details",
                        "type": "boolean",
                        "description": "Fetch each public job page for the full description, application URL, validity date and street-level location fields.",
                        "default": true
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum jobs per query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum unique job rows saved for each search query.",
                        "default": 10
                    },
                    "maxPagesPerQuery": {
                        "title": "Maximum search pages per query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety cap for source pagination, especially when using posting-age filters.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
