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

Extract company profiles and job hiring data from Welcome to the Jungle (WTTJ), Europe's top job platform. Filter by industry sector, keyword, and country to find actively hiring companies.

- **URL**: https://apify.com/automation-lab/welcome-to-the-jungle-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Welcome to the Jungle Jobs Scraper

Extract company profiles and active job hiring data from [Welcome to the Jungle](https://www.welcometothejungle.com) — Europe's leading job platform. Filter by industry sector, keyword, country, and minimum open positions. Great for B2B lead generation, market research, and talent acquisition intelligence.

---

### 🌴 What does it do?

This actor connects to the Welcome to the Jungle (WTTJ) public API and extracts structured company data including:

- Company name, slug, and WTTJ profile URL
- Full company description (HTML-stripped)
- Industry sectors (e.g., Tech > SaaS / Cloud Services)
- Headquarters and office locations
- Employee headcount range
- Number of currently open job listings
- Company logo URL
- Gender equality index scores (French regulatory metric)

Filter results by keyword search, industry sector, country code, and minimum open positions count to build targeted lists of actively hiring companies.

---

### 👤 Who is it for?

**B2B Sales & Account Executives** — Identify tech companies in France, Germany, or across Europe that are actively hiring, as a proxy for growth and budget availability.

**HR Recruiters & Talent Sourcers** — Discover companies in specific industries that are rapidly hiring, and reach out before candidates get to them.

**Market Researchers** — Map the European startup ecosystem by sector, country, and headcount for competitive intelligence or investor due diligence.

**Business Developers** — Find companies expanding in your target geography and sector to prioritize outreach.

**Data Analysts** — Collect structured company snapshots from WTTJ as part of a broader lead enrichment or market analysis pipeline.

---

### 💡 Why use this actor?

Welcome to the Jungle hosts over 10,000 company profiles, primarily European tech, startup, and enterprise companies. Unlike LinkedIn or generic business databases, WTTJ profiles emphasize company culture, actual open positions, and employer branding — making it an ideal source for quality lead generation.

- **No scraping blocks** — uses WTTJ's public API directly
- **Structured output** — flat JSON with company metadata, ideal for CRMs and spreadsheets
- **Sector filters** — target niche industries using WTTJ's taxonomy
- **Actively hiring filter** — filter to companies with open positions right now

---

### 📋 Data extracted

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Company name |
| `slug` | string | WTTJ identifier slug |
| `reference` | string | Internal WTTJ reference ID |
| `description` | string | Company description (HTML stripped) |
| `sectors` | array | Industry sectors (e.g., `"Tech > SaaS / Cloud Services"`) |
| `primarySector` | string | Top-level sector (e.g., `"Tech"`) |
| `headquarters` | string | City + country code of HQ (e.g., `"Paris, FR"`) |
| `offices` | array | All office locations with city, country code, and HQ flag |
| `nbEmployees` | integer | Employee count (or `null` if not disclosed) |
| `jobsCount` | integer | Number of currently open job listings |
| `url` | string | Full WTTJ company profile URL |
| `logoUrl` | string | Company logo image URL |
| `labels` | array | Company badges/awards (e.g., "Top Employer") |
| `equalityIndex` | number | French gender equality index score (0-100), or `null` |

---

### 💰 Pricing — How much does it cost to scrape Welcome to the Jungle companies?

This actor uses **Pay-Per-Event (PPE)** pricing — you are charged only for results extracted, not for compute time.

| Event | Price |
|-------|-------|
| Run started (flat fee) | $0.005 |
| Company extracted (FREE) | $0.00115 |
| Company extracted (BRONZE) | $0.001 |
| Company extracted (SILVER) | $0.00078 |
| Company extracted (GOLD) | $0.0006 |
| Company extracted (PLATINUM) | $0.0004 |
| Company extracted (DIAMOND) | $0.00028 |

**Example costs:**
- Extract 50 companies (typical lead gen run): ~$0.055 on BRONZE plan
- Extract 100 companies (max per query): ~$0.105 on BRONZE plan
- DIAMOND plan users: 100 companies for ~$0.033

Apify's free plan gives you $5 of monthly credit, enough to extract 4,900+ company profiles.

---

### 🚀 How to use

1. Go to the actor's **Input** tab.
2. Set your **Search keyword** (e.g., `"fintech"`, `"AI startup"`, `"SaaS"`).
3. Optionally set **Industry sectors** using WTTJ sector references (see below).
4. Set **Minimum open positions** to `1` to only get actively hiring companies.
5. Click **Start** and get your results in seconds.

**Common WTTJ sector references:**
- `tech-1` — Technology
- `banking-insurance-finance` — Banking / Insurance / Finance
- `health-social-environment` — Health / Social / Environment
- `consulting-audit` — Consulting / Audit
- `distribution-1` — Distribution / E-commerce
- `industry-1` — Industry / Manufacturing
- `culture-media-entertainment` — Culture / Media / Entertainment

---

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `query` | string | `""` | Keyword to search for companies |
| `sectors` | array | `[]` | WTTJ sector references to filter by |
| `country` | string | `""` | ISO 2-letter country code to filter HQ (e.g., `"FR"`, `"DE"`) |
| `minJobsCount` | integer | `0` | Minimum number of open job listings required |
| `maxResults` | integer | `100` | Max companies to extract (up to 100 per query) |

---

### 📦 Output example

```json
{
  "name": "Qonto",
  "slug": "qonto",
  "reference": "U2ADSPE",
  "description": "Qonto is the business finance solution that provides entrepreneurs with all the tools to manage their finances easily from a single, integrated platform.",
  "sectors": ["Banking / Insurance / Finance > Fintech / Banking", "Tech > SaaS / Cloud Services"],
  "primarySector": "Banking / Insurance / Finance",
  "headquarters": "Paris, FR",
  "offices": [
    { "city": "Paris", "countryCode": "FR", "isHeadquarter": true },
    { "city": "Berlin", "countryCode": "DE", "isHeadquarter": false }
  ],
  "nbEmployees": 1200,
  "jobsCount": 47,
  "url": "https://www.welcometothejungle.com/en/companies/qonto",
  "logoUrl": "https://cdn-images.welcometothejungle.com/...",
  "labels": [],
  "equalityIndex": 92
}
````

***

### 💡 Tips & tricks

- **Lead gen workflow**: Set `minJobsCount: 1` and `query: "your ICP keyword"` to instantly get a list of companies hiring in your target segment.
- **Country targeting**: Use `country: "DE"` to restrict results to companies with HQ in Germany — great for region-specific campaigns.
- **Sector stacking**: Pass multiple sector references in `sectors` to combine results from multiple industries.
- **Large job counts**: Companies with high `jobsCount` are in high growth mode — prioritize these for outreach.
- **Equality index**: The `equalityIndex` field reflects French regulatory gender equality compliance scores — useful for ESG-aware sourcing.

***

### 🔗 Integrations

#### CRM lead import (HubSpot / Salesforce)

Use the actor's dataset output with Apify's **Make** or **Zapier** integration to automatically import new company leads into your CRM whenever the actor runs.

**Example Make scenario:**

1. Trigger: Apify actor run finished
2. Filter: `jobsCount >= 10`
3. Action: Create HubSpot company record with name, URL, sector, headquarters

#### Google Sheets pipeline

Schedule this actor daily and use the **Apify → Google Sheets** integration to maintain a live spreadsheet of growing European companies, updated automatically.

#### Multi-source lead enrichment

Combine WTTJ company data with our [LinkedIn Company Scraper](https://apify.com/automation-lab/linkedin-company-scraper) or [Email Finder](https://apify.com/automation-lab/email-finder) to enrich leads with LinkedIn profiles and decision-maker contacts.

***

### 🤖 MCP — Use with Claude Code / Claude Desktop

You can use this actor directly in Claude Code, Claude Desktop, or any MCP-compatible AI assistant:

**Claude Code:**

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/welcome-to-the-jungle-jobs-scraper"
```

**Claude Desktop / Cursor / VS Code (`claude_desktop_config.json`):**

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/welcome-to-the-jungle-jobs-scraper",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

**Example prompts for Claude:**

- *"Find 20 French fintech companies on WTTJ that are actively hiring"*
- *"Get me a list of European AI startups with at least 5 open positions"*
- *"List tech companies in Germany from Welcome to the Jungle"*

***

### 🖥️ API usage

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('automation-lab/welcome-to-the-jungle-jobs-scraper').call({
    query: 'fintech',
    country: 'FR',
    minJobsCount: 1,
    maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("automation-lab/welcome-to-the-jungle-jobs-scraper").call(run_input={
    "query": "fintech",
    "country": "FR",
    "minJobsCount": 1,
    "maxResults": 50,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~welcome-to-the-jungle-jobs-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "fintech",
    "country": "FR",
    "minJobsCount": 1,
    "maxResults": 50
  }'
```

***

### ⚖️ Legal, legality & terms of service

This actor accesses the Welcome to the Jungle public API which is used to power their own website's search functionality. The data extracted is company profile data that WTTJ makes publicly accessible on their platform.

**Use this actor responsibly:**

- Do not use extracted data to spam companies or individuals
- Respect rate limits — avoid running the actor excessively in a short period
- Review WTTJ's Terms of Service before commercial use of the data
- This actor is designed for legitimate market research, lead generation, and competitive intelligence use cases

***

### ❓ FAQ

**Q: Why does the actor always return the same 100 companies even with different offsets?**
A: The WTTJ public API returns a curated set of featured/recent companies per search query. Use different `query` keywords to discover more companies — each search term returns a different set.

**Q: Can I get more than 100 companies per run?**
A: The WTTJ API returns a maximum of 100 results per search request. To build a larger list, run multiple times with different keywords or sector filters and combine the results (the actor deduplicates by company reference within a single run).

**Q: Why isn't the actor returning companies from my target country?**
A: The `country` filter matches on HQ office location. If a company is HQ'd in another country but has offices in your target country, it won't be included. Try using just the `query` field for broader results, then filter in your downstream tool.

**Q: The actor says "0 results" — what's wrong?**
A: Check that your sector reference is a valid WTTJ sector slug (e.g., `tech-1`, not `Technology`). Also try removing the `minJobsCount` filter to see if companies without open positions are the issue.

**Q: Can I scrape actual job listing details (job title, salary, description)?**
A: This actor focuses on company-level data including open position counts. For individual job listing details, check our [Google Jobs Scraper](https://apify.com/automation-lab/google-jobs-scraper) or [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper).

***

### 🔗 Related scrapers

- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper)
- [Google Jobs Scraper](https://apify.com/automation-lab/google-jobs-scraper)
- [Indeed Scraper](https://apify.com/automation-lab/indeed-scraper)
- [Glassdoor Jobs Scraper](https://apify.com/automation-lab/glassdoor-jobs-scraper)
- [LinkedIn Company Scraper](https://apify.com/automation-lab/linkedin-company-scraper)
- [Email Finder](https://apify.com/automation-lab/email-finder)

# Actor input Schema

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

Keyword to search for companies (e.g. "fintech", "SaaS", "AI startup"). Leave empty to browse all featured companies.

## `sectors` (type: `array`):

Filter by WTTJ sector references (e.g. "tech-1", "banking-insurance-finance"). Leave empty for all sectors.

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

Filter companies by HQ country code (ISO 2-letter, e.g. "FR", "DE", "US"). Leave empty for all countries.

## `minJobsCount` (type: `integer`):

Only return companies with at least this many open job listings. Use 1 to restrict to actively hiring companies.

## `maxResults` (type: `integer`):

Maximum number of companies to extract (up to 100 per query).

## Actor input object example

```json
{
  "query": "tech startup",
  "sectors": [],
  "minJobsCount": 1,
  "maxResults": 20
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "query": "tech startup",
    "sectors": [],
    "country": "",
    "minJobsCount": 1,
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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": "tech startup",
    "sectors": [],
    "country": "",
    "minJobsCount": 1,
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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": "tech startup",
  "sectors": [],
  "country": "",
  "minJobsCount": 1,
  "maxResults": 20
}' |
apify call automation-lab/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=automation-lab/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": "Extract company profiles and job hiring data from Welcome to the Jungle (WTTJ), Europe's top job platform. Filter by industry sector, keyword, and country to find actively hiring companies.",
        "version": "0.1",
        "x-build-id": "FQn0pXAHv8xq2Vrzl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~welcome-to-the-jungle-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~welcome-to-the-jungle-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~welcome-to-the-jungle-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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": {
                    "query": {
                        "title": "🔍 Search keyword",
                        "type": "string",
                        "description": "Keyword to search for companies (e.g. \"fintech\", \"SaaS\", \"AI startup\"). Leave empty to browse all featured companies."
                    },
                    "sectors": {
                        "title": "🏭 Industry sectors",
                        "type": "array",
                        "description": "Filter by WTTJ sector references (e.g. \"tech-1\", \"banking-insurance-finance\"). Leave empty for all sectors.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "🌍 Country code",
                        "type": "string",
                        "description": "Filter companies by HQ country code (ISO 2-letter, e.g. \"FR\", \"DE\", \"US\"). Leave empty for all countries."
                    },
                    "minJobsCount": {
                        "title": "💼 Minimum open positions",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return companies with at least this many open job listings. Use 1 to restrict to actively hiring companies."
                    },
                    "maxResults": {
                        "title": "📊 Max results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of companies to extract (up to 100 per query)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
