# Pnet Job Scraper (`shahidirfan/pnet-job-scraper`) Actor

Meet the Pnet Job Scraper, a lightweight actor designed to efficiently extract job listings from Pnet. Fast, reliable, and easy to deploy. For optimal performance and to avoid blocking, using residential proxies is highly recommended. Streamline your recruitment data gathering today!

- **URL**: https://apify.com/shahidirfan/pnet-job-scraper.md
- **Developed by:** [Shahid Irfan](https://apify.com/shahidirfan) (community)
- **Categories:** Jobs, Developer tools, Automation
- **Stats:** 18 total users, 7 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 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

## 🎯 Pnet Job Scraper - Complete Job Data Extraction

<div align="center">

![Pnet Scraper](https://img.shields.io/badge/Apify-Actor-blue?style=for-the-badge&logo=apify)
![Job Scraping](https://img.shields.io/badge/Job_Scraping-Automated-green?style=for-the-badge)
![Data Extraction](https://img.shields.io/badge/Data_Extraction-Complete-orange?style=for-the-badge)

**Extract comprehensive job listings from Pnet.co.za with intelligent pagination and detailed information capture**

[🚀 Run on Apify](https://apify.com/) • [📖 Documentation](#-documentation) • [💡 Examples](#-usage-examples)

</div>

---

### 🌟 Why Choose Pnet Job Scraper?

**Pnet Job Scraper** is your complete solution for automated job data extraction from South Africa's leading job portal. Whether you're building a job search platform, conducting market research, or gathering recruitment intelligence, this scraper delivers structured, comprehensive job data with enterprise-grade reliability.

#### ✨ Key Benefits

- **📊 Complete Data Coverage** - Extract titles, companies, locations, salaries, descriptions, and metadata
- **🔄 Intelligent Automation** - Handles pagination, retries, and anti-bot measures automatically
- **⚡ High Performance** - Optimized for speed with smart rate limiting and session management
- **🛡️ Enterprise Ready** - Built-in proxy rotation and error handling for reliable operation
- **📈 Scalable** - Process thousands of jobs with configurable limits and filtering
- **🎯 Flexible Search** - Keyword, location, and category-based job discovery

---

### 🚀 Quick Start

#### Basic Job Search
```json
{
  "keyword": "software engineer",
  "location": "Johannesburg",
  "results_wanted": 100
}
````

#### Advanced Configuration

```json
{
  "keyword": "data scientist",
  "location": "Cape Town",
  "results_wanted": 500,
  "collectDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

**🎯 Ready to scrape? [Start your first run now!](https://apify.com/)**

***

### 📋 Features

<table>
<tr>
<td>

#### 🔍 Smart Data Extraction

- **Job Titles & Companies** - Accurate extraction with fallback methods
- **Location Data** - City, region, and area information
- **Salary Information** - Range, type, and currency details
- **Job Descriptions** - Full HTML and plain text versions
- **Posting Dates** - Relative and absolute timestamps
- **Job Categories** - Industry and role classifications

</td>
<td>

#### ⚙️ Advanced Automation

- **Intelligent Pagination** - Automatic page navigation and discovery
- **Session Management** - Smart session rotation for reliability
- **Rate Limiting** - Built-in delays to respect website limits
- **Error Recovery** - Automatic retries with exponential backoff
- **Anti-Bot Evasion** - Multiple techniques to avoid detection
- **Proxy Integration** - Residential proxy support for scale

</td>
</tr>
</table>

***

### 📥 Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `keyword` | `string` | No | `"admin"` | Primary search term (e.g., "software engineer", "marketing manager") |
| `location` | `string` | No | `""` | Geographic filter (e.g., "Johannesburg", "Cape Town", "Durban") |
| `category` | `string` | No | `""` | Job category or industry filter |
| `startUrl` | `string` | No | - | Custom Pnet URL to begin scraping |
| `url` | `string` | No | - | Alternative custom URL parameter |
| `results_wanted` | `integer` | No | `100` | Target number of jobs to collect (1-10000) |
| `max_pages` | `integer` | No | `10` | Maximum search pages to process |
| `collectDetails` | `boolean` | No | `true` | Fetch full job descriptions from detail pages |
| `proxyConfiguration` | `object` | No | - | Proxy settings for enhanced reliability |

#### 🔧 Configuration Examples

##### Entry-Level Jobs Search

```json
{
  "keyword": "graduate",
  "location": "Johannesburg",
  "results_wanted": 200,
  "max_pages": 15
}
```

##### Senior Management Positions

```json
{
  "keyword": "director",
  "category": "management",
  "results_wanted": 50,
  "collectDetails": true
}
```

##### Custom URL Scraping

```json
{
  "startUrl": "https://www.pnet.co.za/jobs/it",
  "results_wanted": 300,
  "max_pages": 20
}
```

##### Large-Scale Data Collection

```json
{
  "keyword": "engineer",
  "results_wanted": 1000,
  "max_pages": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "ZA"
  }
}
```

***

### 📤 Output Data Schema

The scraper produces structured JSON records optimized for data analysis and integration.

#### Core Job Fields

| Field | Type | Description | Example |
|-------|------|-------------|---------|
| `title` | `string` | Job position title | `"Senior Software Engineer"` |
| `company` | `string` | Hiring organization | `"TechCorp Solutions Ltd"` |
| `location` | `string` | Job location details | `"Johannesburg, Gauteng"` |
| `salary` | `string` | Compensation information | `"R500,000 - R700,000 per annum"` |
| `date_posted` | `string` | Posting timestamp | `"2 days ago"` |
| `job_url` | `string` | Direct job link | `"https://www.pnet.co.za/job/..."` |

#### Extended Information

| Field | Type | Description | Example |
|-------|------|-------------|---------|
| `job_type` | `string` | Employment type | `"Full-time"` |
| `job_category` | `string` | Industry category | `"Information Technology"` |
| `description_html` | `string` | Full HTML description | `"<div><p>We are seeking..."` |
| `description_text` | `string` | Plain text description | `"We are seeking a talented..."` |

#### 📊 Sample Output Record

```json
{
  "title": "Senior Full Stack Developer",
  "company": "Digital Innovations Ltd",
  "location": "Cape Town, Western Cape",
  "salary": "R450,000 - R650,000 per annum",
  "date_posted": "1 day ago",
  "job_type": "Full-time",
  "job_category": "Information Technology",
  "description_html": "<div><p>Join our dynamic team as a Senior Full Stack Developer...</p></div>",
  "description_text": "Join our dynamic team as a Senior Full Stack Developer...",
  "job_url": "https://www.pnet.co.za/job/senior-full-stack-developer/digital-innovations-job12345"
}
```

***

### 🎯 Usage Examples

#### Basic API Integration

##### REST API Access

```bash
## Get results as JSON
curl "https://api.apify.com/v2/acts/YOUR-ACTOR-ID/runs/YOUR-RUN-ID/dataset/items?format=json"

## Export as CSV
curl "https://api.apify.com/v2/acts/YOUR-ACTOR-ID/runs/YOUR-RUN-ID/dataset/items?format=csv"
```

##### Python Integration

```python
import requests

## Fetch job data
response = requests.get(
    'https://api.apify.com/v2/acts/YOUR-ACTOR-ID/runs/YOUR-RUN-ID/dataset/items?format=json',
    params={'token': 'YOUR-API-TOKEN'}
)

jobs = response.json()

## Process and analyze
for job in jobs:
    print(f"📋 {job['title']} at {job['company']}")
    print(f"📍 Location: {job['location']}")
    print(f"💰 Salary: {job['salary']}")
    print("---")
```

##### JavaScript/Node.js

```javascript
const Apify = require('apify');

async function processJobs() {
    const run = await Apify.call('YOUR-ACTOR-ID', {
        keyword: 'javascript developer',
        location: 'Johannesburg',
        results_wanted: 50
    });

    const dataset = await Apify.openDataset(run.defaultDatasetId);
    const jobs = await dataset.getData().then(data => data.items);

    jobs.forEach(job => {
        console.log(`${job.title} - ${job.company} (${job.location})`);
    });
}

processJobs();
```

***

### ⚙️ Advanced Configuration

#### Proxy Settings for Scale

```json
{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "ZA"
  }
}
```

#### Performance Optimization

| Setting | Recommended | Description |
|---------|-------------|-------------|
| `results_wanted` | 100-500 | Balance data needs with processing time |
| `max_pages` | 10-25 | Prevent excessive crawling |
| `collectDetails` | `true` | Get complete job information |

#### Error Handling & Reliability

- **Automatic Retries** - Failed requests are retried with smart backoff
- **Session Rotation** - Fresh sessions prevent blocking
- **Rate Limiting** - Respectful delays between requests
- **Circuit Breaker** - Automatic failure detection and recovery

***

### 💼 Use Cases & Applications

#### 🎯 Recruitment & HR

- **Talent Pipeline Building** - Identify qualified candidates across South African regions
- **Market Intelligence** - Track job market trends and salary ranges in South Africa
- **Competitor Analysis** - Monitor hiring patterns of industry peers

#### 📊 Market Research

- **Industry Analysis** - Study job market demand by sector and location in South Africa
- **Salary Benchmarking** - Compare compensation across roles and companies
- **Geographic Insights** - Understand regional job market dynamics in South Africa

#### 🤖 Automation & Integration

- **Job Board Aggregation** - Combine data from multiple South African sources
- **Alert Systems** - Monitor new job postings in specific areas
- **Data Enrichment** - Enhance CRM and applicant tracking systems

#### 📈 Business Intelligence

- **Workforce Planning** - Forecast hiring needs based on South African market data
- **Economic Indicators** - Track employment trends and opportunities in South Africa
- **Career Development** - Identify in-demand skills and roles in South Africa

***

### 🔒 Compliance & Best Practices

#### Responsible Scraping

- **Rate Limiting** - Built-in delays respect website performance
- **Session Management** - Mimics human browsing patterns
- **Error Recovery** - Graceful handling of temporary issues

#### Data Usage Guidelines

- **Terms Compliance** - Adhere to Pnet.co.za terms of service
- **Privacy Respect** - Handle personal data appropriately
- **Legal Compliance** - Ensure usage complies with applicable laws

#### Performance Considerations

- **Resource Management** - Efficient memory and network usage
- **Scalability** - Designed for high-volume data collection
- **Monitoring** - Comprehensive logging and error tracking

***

### 🆘 Support & Resources

#### Getting Help

- **📧 Support** - Contact via Apify platform for technical assistance
- **🐛 Bug Reports** - Report issues through the Apify console
- **💡 Feature Requests** - Suggest improvements and new capabilities

#### Documentation

- **📖 API Reference** - Complete parameter and output documentation
- **🎯 Examples** - Sample configurations for common use cases
- **🔧 Configuration Guide** - Advanced setup and optimization tips

#### Updates & Maintenance

- **🔄 Regular Updates** - Continuous improvements and compatibility updates
- **📢 Changelog** - Track new features and bug fixes
- **🛡️ Reliability** - Enterprise-grade stability and performance

***

<div align="center">

### 🚀 Ready to Extract Job Data?

**[Start Scraping Jobs Now](https://apify.com/)**

**Extract • Analyze • Integrate**

*Built for reliability, optimized for performance*

***

**🏷️ Keywords:** pnet job scraper, south africa job scraper, job scraping, recruitment data, job listings, employment data, job market analysis, automated scraping, HR data, job search automation, career data, workforce intelligence, pnet.co.za scraper, south african jobs

</div>

# Actor input Schema

## `startUrl` (type: `string`):

Start scraping from a specific Pnet search URL. If provided, this will be used instead of Keyword/Location.

## `keyword` (type: `string`):

Job search keyword(s), e.g., 'Software Developer', 'Marketing Manager', 'Data Analyst'.

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

Location to filter results (leave empty for broad results).

## `postedWithin` (type: `string`):

Filter jobs posted within the last N days. Leave empty for all jobs.

## `results_wanted` (type: `integer`):

The maximum number of jobs to collect. Leave empty to collect all available jobs.

## `max_pages` (type: `integer`):

A safety cap on the number of search result pages to visit.

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

Proxy settings for reliable scraping. Residential proxies are recommended for anti-blocking.

## Actor input object example

```json
{
  "keyword": "admin",
  "results_wanted": 20,
  "max_pages": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "keyword": "admin",
    "results_wanted": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("shahidirfan/pnet-job-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 = {
    "keyword": "admin",
    "results_wanted": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("shahidirfan/pnet-job-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 '{
  "keyword": "admin",
  "results_wanted": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call shahidirfan/pnet-job-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pnet Job Scraper",
        "description": "Meet the Pnet Job Scraper, a lightweight actor designed to efficiently extract job listings from Pnet. Fast, reliable, and easy to deploy. For optimal performance and to avoid blocking, using residential proxies is highly recommended. Streamline your recruitment data gathering today!",
        "version": "0.0",
        "x-build-id": "y3MguQlm4IhjTQFBC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/shahidirfan~pnet-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-shahidirfan-pnet-job-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/shahidirfan~pnet-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-shahidirfan-pnet-job-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/shahidirfan~pnet-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-shahidirfan-pnet-job-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": {
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "Start scraping from a specific Pnet search URL. If provided, this will be used instead of Keyword/Location."
                    },
                    "keyword": {
                        "title": "Keyword (if not using Start URL)",
                        "type": "string",
                        "description": "Job search keyword(s), e.g., 'Software Developer', 'Marketing Manager', 'Data Analyst'."
                    },
                    "location": {
                        "title": "Location (if not using Start URL)",
                        "type": "string",
                        "description": "Location to filter results (leave empty for broad results)."
                    },
                    "postedWithin": {
                        "title": "Posted within (days)",
                        "enum": [
                            "1",
                            "3",
                            "7"
                        ],
                        "type": "string",
                        "description": "Filter jobs posted within the last N days. Leave empty for all jobs."
                    },
                    "results_wanted": {
                        "title": "Maximum number of jobs",
                        "minimum": 1,
                        "type": "integer",
                        "description": "The maximum number of jobs to collect. Leave empty to collect all available jobs.",
                        "default": 20
                    },
                    "max_pages": {
                        "title": "Maximum number of pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "A safety cap on the number of search result pages to visit.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings for reliable scraping. Residential proxies are recommended for anti-blocking."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
