# SEEK Job Scraper (`epicscrapers/seek-job-scraper`) Actor

From $0.5/1000 results | Scrapes job listings from SEEK Australia (au.seek.com) with full filter support — keywords, location, salary, work type, classification, and date range. No API!

- **URL**: https://apify.com/epicscrapers/seek-job-scraper.md
- **Developed by:** [Epic Scrapers](https://apify.com/epicscrapers) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 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.
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

## SEEK Job Scraper

**Scrape job listings from [SEEK Australia](https://au.seek.com) — the country's #1 job marketplace — without needing an API key or account.** The SEEK Job Scraper extracts job title, company, salary, location, work type, classification, listing date, and more from SEEK's search results. It supports all the same filters you see on the SEEK website: keywords, location, salary range, work type, work arrangement, classification, date posted, and distance. Built for job market analysts, recruiters, HR researchers, and anyone who needs **bulk job data from SEEK** without manually copying and pasting.

### What can the SEEK Job Scraper do?

-  **Search SEEK by keywords and location** — just like you would on the website
-  **Filter by salary range** — set minimum and maximum salary
-  **Filter by date posted** — get only jobs posted within the last 1, 3, 7, 14, 30, or 60 days
-  **Filter by work type** — Full Time, Part Time, Contract/Temp, or Casual
-  **Filter by work arrangement** — On-site or Hybrid
-  **Filter by classification** — narrow results to specific job categories (IT, Design, Marketing, etc.)
-  **Paginate through results** — scrape up to 100 pages automatically
-  **Export to JSON, CSV, Excel, or HTML** — via Apify's dataset export

### What data can you extract from SEEK?

Each job listing yields the following data fields:

| Field | Description | Example |
|-------|-------------|---------|
| `id` | Unique SEEK job ID | `91959303` |
| `title` | Job title | `Software Engineer` |
| `teaser` | Short description | `Join a fast-growing startup...` |
| `companyName` | Employer/company name | `Techno Recruitment` |
| `advertiserName` | Advertiser name | `Techno Recruitment` |
| `salaryLabel` | Salary information | `Salary + Equity up to $300k` |
| `listingDate` | ISO 8601 date posted | `2026-05-07T01:55:26Z` |
| `listingDateDisplay` | Relative date | `13h ago` |
| `isFeatured` | Promoted/featured job | `true` or `false` |
| `locations` | Job locations | `["Sydney NSW"]` |
| `workTypes` | Employment type | `["Full time"]` |
| `workArrangements` | On-site/Hybrid/Remote | `["Hybrid"]` |
| `classificationNames` | Job categories | `["Information & Communication Technology"]` |
| `subclassificationNames` | Specific sub-categories | `["Engineering - Software"]` |
| `bulletPoints` | Key selling points | `["Be part of a world class..."]` |
| `brandingSerpLogoUrl` | Company logo URL | `https://...` |
| `displayType` | Standard or promoted | `promoted` or `standard` |

### How to scrape SEEK with the SEEK Job Scraper

1. **Open the Actor** on Apify Console and go to the Input tab.

2. **Enter your search keywords** — for example, `software engineer` for job titles, or `graphic designer` for design roles. This is the only required field.

3. **Set your location** — type a city, suburb, or region (e.g., `Sydney NSW`, `Melbourne VIC`, `Brisbane QLD`). Leave as `All Australia` to search nationwide.

4. **Apply filters (optional)** — use the Salary Range, Work Type, Date Range, Classification, and other fields to narrow your results.

5. **Click Run** — the Actor will fetch results from SEEK's search API and push each listing to the dataset.

6. **Download your data** — once the run completes, open the Dataset tab and export in JSON, CSV, Excel, or HTML format.

### Input

The Input tab accepts the following fields:

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `keywords` | text | `software engineer` | **Required.** Your search keywords |
| `where` | text | `All Australia` | Location to search in |
| `maxPages` | number | `5` | Maximum result pages to scrape (0 = unlimited) |
| `pageSize` | number | `22` | Results per page (max 100) |
| `sortMode` | select | `KeywordRelevance` | Sort by Relevance or Date |
| `salaryRange` | text | `0-` | Salary range (e.g., `50000-`, `80000-120000`) |
| `salaryType` | select | `annual` | Annual or Hourly salary |
| `workType` | text | — | Work type IDs: 242 (Full Time), 243 (Part Time), 244 (Contract/Temp), 245 (Casual) |
| `workArrangement` | text | — | 2 (On-site), 3 (Hybrid). Comma-separate for multiple. |
| `daterange` | number | `0` | Days since posted: 1, 3, 7, 14, 30, 60 (0 = any time) |
| `classification` | text | — | Classification ID (e.g., `6281` for IT, `6263` for Design) |
| `subclassification` | text | — | Subclassification ID (e.g., `6290` for Engineering - Software) |
| `distance` | number | `50` | Search radius from the location in km |

### Output

Results are stored in the default Apify Dataset. Here's an example of a single job listing:

```json
{
  "id": "91959303",
  "title": "Software Engineer",
  "teaser": "Software Engineer",
  "companyName": "Techno Recruitment",
  "advertiserId": "62855691",
  "advertiserName": "Techno Recruitment",
  "salaryLabel": "Salary + Significant Equity up to $300k",
  "listingDate": "2026-05-07T01:55:26Z",
  "listingDateDisplay": "13h ago",
  "isFeatured": true,
  "roleId": "software-engineer",
  "displayType": "promoted",
  "locations": [
    "Sydney NSW"
  ],
  "locationCountries": [
    "AU"
  ],
  "workTypes": [
    "Full time"
  ],
  "workArrangements": [
    "Hybrid"
  ],
  "classificationNames": [
    "Information & Communication Technology"
  ],
  "classificationIds": [
    "6281"
  ],
  "subclassificationNames": [
    "Engineering - Software"
  ],
  "subclassificationIds": [
    "6290"
  ],
  "bulletPoints": [
    "Be part of a world class AI Engineering team building AI Engines within FinTech",
    "Serious equity component, autonomy and no beauracracy",
    "Rapidly ideate, prototype and ship, working within a totally AI fluent business"
  ],
  "companyProfileStructuredDataId": 3163898,
  "brandingSerpLogoUrl": "https://bx-branding-gateway.cloud.seek.com.au/836982fc-0132-4f66-ad57-c0fd83fbe4c8.1/jdpLogo"
}
````

You can download the full dataset in **JSON, CSV, Excel, or HTML** from the Dataset tab in Apify Console, or access it programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Is it legal to scrape SEEK?

The SEEK Job Scraper only collects **publicly available information** from SEEK's job search results. It does not:

- Access private or authenticated areas of the website
- Scrape candidate or recruiter profiles
- Collect personal data about job applicants
- Submit applications or interact with SEEK as a user

Always review [SEEK's Terms of Service](https://seek.com.au/terms-and-conditions/) before use. This tool is intended for legitimate purposes such as labour market analysis, recruitment research, and competitive intelligence.

### Why use the SEEK Job Scraper instead of the official API?

SEEK **does not offer a public API** for searching or exporting job listings. If you need to collect job data from SEEK programmatically — for market research, salary analysis, or recruitment automation — this Actor provides the only practical solution.

### FAQ

#### How do I find classification and subclassification IDs?

SEEK's website uses numeric IDs for each job category. Common ones include:

- **6281** — Information & Communication Technology
- **6290** — Engineering - Software
- **6263** — Design & Architecture
- **6268** — Graphic Design
- **6008** — Marketing & Communications

#### Does this Actor scrape full job descriptions?

It extracts the **search result data** — title, teaser, company, salary, location, work type, and other fields available in the search API. It does not open individual job detail pages for the full description.

#### Can I run this on a schedule?

Yes. Apify lets you schedule Actors to run daily, weekly, or at any custom interval. You can automatically collect new job listings as they're posted on SEEK.

#### Can I filter by Remote/WFH jobs?

The Actor supports the work arrangement IDs. Use `2` (On-site) or `3` (Hybrid) instead.

#### Do I need a SEEK account?

No. All data comes from SEEK's public search API — no login or authentication required.

#### How many results can I scrape?

You can configure up to 100 pages with up to 100 results per page, giving you a maximum of **10,000 job listings** per search. Use the `maxPages` and `pageSize` settings to control the volume.

### Apify platform features

This Actor takes full advantage of the Apify platform:

- **Scheduling** — run automatically on any schedule
- **Integrations** — connect output to Google Sheets, Slack, Airtable, Make, Zapier, n8n, and more
- **Dataset storage** — all results stored in the cloud, ready to export
- **Webhooks** — get notified when runs complete

### Support

Found a bug or have a feature request? Open an issue on the GitHub repository. Feedback and contributions are welcome.

***

-

# Actor input Schema

## `keywords` (type: `string`):

Job search keywords (e.g., 'software engineer', 'graphic designer')

## `where` (type: `string`):

Location to search in (e.g., 'Sydney NSW', 'Melbourne VIC', 'All Australia')

## `maxPages` (type: `integer`):

Maximum number of result pages to scrape (0 = unlimited)

## `pageSize` (type: `integer`):

Number of results per page (max 100)

## `sortMode` (type: `string`):

How to sort results

## `salaryRange` (type: `string`):

Salary range filter (e.g., '0-', '50000-', '80000-120000')

## `salaryType` (type: `string`):

Salary type filter

## `workType` (type: `string`):

Work type filter (242=Full Time, 243=Part Time, 244=Contract/Temp, 245=Casual). Comma-separate for multiple.

## `workArrangement` (type: `string`):

Work arrangement filter (2=On-site, 3=Hybrid). Comma-separate for multiple.

## `daterange` (type: `integer`):

Only show jobs posted within this many days (0 = any time, 1, 3, 7, 14, 30, 60)

## `classification` (type: `string`):

Classification ID to filter by (optional, e.g. '6263' for Design & Architecture). Get IDs from the counts API.

## `subclassification` (type: `string`):

Subclassification ID to filter by (optional, e.g. '6268' for Graphic Design).

## `distance` (type: `integer`):

Search radius in kilometres from the location

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

Proxy configuration for requests (curl-cffi uses its own TLS fingerprinting, but Apify proxy can be used for IP rotation)

## Actor input object example

```json
{
  "keywords": "software engineer",
  "where": "All Australia",
  "maxPages": 5,
  "pageSize": 22,
  "sortMode": "KeywordRelevance",
  "salaryRange": "0-",
  "salaryType": "annual",
  "workType": "",
  "workArrangement": "",
  "daterange": 0,
  "classification": "",
  "subclassification": "",
  "distance": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped job listings stored in the default dataset. Each item is a job with fields like id, title, companyName, salaryLabel, listingDate, locations, workTypes, workArrangements, classificationNames, bulletPoints, etc.

# 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 = {
    "keywords": "software engineer",
    "where": "All Australia",
    "maxPages": 5,
    "pageSize": 22,
    "distance": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("epicscrapers/seek-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 = {
    "keywords": "software engineer",
    "where": "All Australia",
    "maxPages": 5,
    "pageSize": 22,
    "distance": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("epicscrapers/seek-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 '{
  "keywords": "software engineer",
  "where": "All Australia",
  "maxPages": 5,
  "pageSize": 22,
  "distance": 50
}' |
apify call epicscrapers/seek-job-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEEK Job Scraper",
        "description": "From $0.5/1000 results | Scrapes job listings from SEEK Australia (au.seek.com) with full filter support — keywords, location, salary, work type, classification, and date range. No API!",
        "version": "0.0",
        "x-build-id": "GWEN5BHGWF5OqqzBj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/epicscrapers~seek-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-epicscrapers-seek-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/epicscrapers~seek-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-epicscrapers-seek-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/epicscrapers~seek-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-epicscrapers-seek-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",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Job search keywords (e.g., 'software engineer', 'graphic designer')",
                        "default": "software engineer"
                    },
                    "where": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to search in (e.g., 'Sydney NSW', 'Melbourne VIC', 'All Australia')",
                        "default": "All Australia"
                    },
                    "maxPages": {
                        "title": "Max Pages",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of result pages to scrape (0 = unlimited)",
                        "default": 5
                    },
                    "pageSize": {
                        "title": "Results Per Page",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of results per page (max 100)",
                        "default": 22
                    },
                    "sortMode": {
                        "title": "Sort Mode",
                        "enum": [
                            "KeywordRelevance",
                            "ListedDate"
                        ],
                        "type": "string",
                        "description": "How to sort results",
                        "default": "KeywordRelevance"
                    },
                    "salaryRange": {
                        "title": "Salary Range",
                        "type": "string",
                        "description": "Salary range filter (e.g., '0-', '50000-', '80000-120000')",
                        "default": "0-"
                    },
                    "salaryType": {
                        "title": "Salary Type",
                        "enum": [
                            "annual",
                            "hourly"
                        ],
                        "type": "string",
                        "description": "Salary type filter",
                        "default": "annual"
                    },
                    "workType": {
                        "title": "Work Type",
                        "type": "string",
                        "description": "Work type filter (242=Full Time, 243=Part Time, 244=Contract/Temp, 245=Casual). Comma-separate for multiple.",
                        "default": ""
                    },
                    "workArrangement": {
                        "title": "Work Arrangement",
                        "type": "string",
                        "description": "Work arrangement filter (2=On-site, 3=Hybrid). Comma-separate for multiple.",
                        "default": ""
                    },
                    "daterange": {
                        "title": "Date Range (days)",
                        "minimum": 0,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Only show jobs posted within this many days (0 = any time, 1, 3, 7, 14, 30, 60)",
                        "default": 0
                    },
                    "classification": {
                        "title": "Classification ID",
                        "type": "string",
                        "description": "Classification ID to filter by (optional, e.g. '6263' for Design & Architecture). Get IDs from the counts API.",
                        "default": ""
                    },
                    "subclassification": {
                        "title": "Subclassification ID",
                        "type": "string",
                        "description": "Subclassification ID to filter by (optional, e.g. '6268' for Graphic Design).",
                        "default": ""
                    },
                    "distance": {
                        "title": "Distance (km)",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Search radius in kilometres from the location",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy configuration for requests (curl-cffi uses its own TLS fingerprinting, but Apify proxy can be used for IP rotation)",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
