# Handshake Jobs Scraper (`maximedupre/handshake-jobs-scraper`) Actor

Collect anonymous public Handshake jobs by keyword, location, search URL, or job URL. Export employer, classification, compensation, dates, and full descriptions.

- **URL**: https://apify.com/maximedupre/handshake-jobs-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Jobs, Business, Automation
- **Stats:** 7 total users, 4 monthly users, 91.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / 1,000 job listings

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/docs.md):

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

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

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

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

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

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

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

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

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


# README

### 🔎 Find and export public Handshake jobs

Recruiters, labor-market researchers, and job-data teams can use Handshake Jobs Scraper to collect anonymous public Handshake listings without a Handshake login or API key. Get job identity, employer, classifications, locations, compensation, dates, and full descriptions in structured rows for analysis and recurring workflows.

- **[Handshake Job Listings](https://apify.com/maximedupre/handshake-jobs-scraper/examples/handshake-job-listings)** — export public listings found by keyword, location, search URL, or direct job URL.
- **[Handshake Internship Search](https://apify.com/maximedupre/handshake-jobs-scraper/examples/handshake-internship-search)** — find internships and co-ops by using keywords and employment-type filters.
- **[Remote Handshake Jobs](https://apify.com/maximedupre/handshake-jobs-scraper/examples/remote-handshake-jobs)** — collect listings explicitly published as remote.
- **[Handshake Salary Data](https://apify.com/maximedupre/handshake-jobs-scraper/examples/handshake-salary-data)** — analyze published compensation, currency, cadence, and unambiguous annualized values.
- **[Handshake Employer Hiring Research](https://apify.com/maximedupre/handshake-jobs-scraper/examples/handshake-employer-hiring-research)** — focus collection on selected employer names.
- **[Handshake Job Market Analysis](https://apify.com/maximedupre/handshake-jobs-scraper/examples/handshake-job-market-analysis)** — compare roles, locations, workplace arrangements, and posting dates.
- **[Handshake Jobs API](https://apify.com/maximedupre/handshake-jobs-scraper/examples/handshake-jobs-api)** — run searches programmatically and consume the resulting dataset through the Apify API.

#### 📦 What data is returned?

Each dataset row represents one unique successful public Handshake job. Missing source values remain `null` or empty arrays rather than being invented.

| Data group | Fields |
| --- | --- |
| Identity | `id`, `url`, `title` |
| Employer | `employer.id`, `employer.name`, `employer.url`, `employer.logoUrl`, `employer.industry`, `employer.description` |
| Classification | `roleTypes`, `employmentTypes`, `workplace` |
| Location | `locations` |
| Compensation | `compensation.minAmount`, `compensation.maxAmount`, `compensation.currency`, `compensation.cadence`, `compensation.annualizedMinAmount`, `compensation.annualizedMaxAmount` |
| Dates | `postedAt`, `expiresAt`, `collectedAt` |
| Description | `descriptionHtml`, `descriptionText` |

#### 🚀 How do I run the Actor?

1. Add at least one value to `keywords`, or submit a public Handshake search or job URL in `startUrls`.
2. Optionally add locations and job filters.
3. Choose `maxDiscoveryItems` to bound search-discovered output.
4. Run the Actor and open the default dataset.

You can combine keyword discovery, public search URLs, and direct job URLs in one run. Duplicate canonical jobs are returned once across all submitted sources.

#### 🎛️ What input can I use?

| Field | What it does |
| --- | --- |
| `keywords` | Job titles, skills, or terms used to discover public listings. |
| `locations` | Cities, regions, countries, or other location terms paired with keyword discovery. |
| `startUrls` | Public Handshake search-result URLs or individual public job URLs. |
| `employers` | Includes jobs whose employer name matches one of the supplied values. |
| `employmentTypes` | Includes published classifications such as full-time, part-time, internship, or co-op. |
| `workplace` | Includes any workplace status, remote jobs only, or on-site jobs only. |
| `postedWithinDays` | Includes jobs with a published date inside the chosen number of days. |
| `compensationFilter` | Applies a minimum published amount for one ISO currency and pay cadence. |
| `maxDiscoveryItems` | Limits matching jobs returned through keyword, location, and search-URL discovery, up to 10,000. Direct job URLs are bounded by the submitted list. |

Example input:

```json
{
  "keywords": ["software engineer"],
  "locations": ["Austin, Texas"],
  "employmentTypes": ["internship"],
  "workplace": "any",
  "postedWithinDays": 30,
  "maxDiscoveryItems": 25
}
````

#### 🧾 What does the output look like?

```json
{
  "id": "9876543",
  "url": "https://app.joinhandshake.com/public/jobs/9876543",
  "title": "Software Engineer Intern",
  "employer": {
    "id": null,
    "name": "Acme Technologies",
    "url": null,
    "logoUrl": "https://example.com/acme-logo.png",
    "industry": "Computer Software",
    "description": null
  },
  "roleTypes": ["Software Development", "Engineering"],
  "employmentTypes": ["internship"],
  "locations": ["Austin, Texas, United States"],
  "workplace": "on-site",
  "compensation": {
    "minAmount": 5000,
    "maxAmount": 6000,
    "currency": "USD",
    "cadence": "month",
    "annualizedMinAmount": 60000,
    "annualizedMaxAmount": 72000
  },
  "postedAt": "2026-07-01T14:30:00.000Z",
  "expiresAt": "2026-08-15T23:59:59.000Z",
  "descriptionHtml": "<p>Join our engineering team.</p>",
  "descriptionText": "Join our engineering team.",
  "collectedAt": "2026-07-18T10:15:30.000Z"
}
```

#### 💳 How does pricing work?

This Actor uses pay-per-event pricing with account-tier rates. You are charged for each unique successful Handshake job listing saved to the default dataset. Duplicates, filtered candidates, unavailable jobs, malformed jobs, and runs with no saved jobs do not create this job charge.

Use `maxDiscoveryItems` to bound search-discovered output and cost. Submitted direct job URLs are separate from that discovery limit and remain bounded by the number of URLs you provide.

#### 🔌 Which integrations are available?

https://www.youtube.com/watch?v=bNACk1\_S\_6w\&list=PLObrtcm1Kw6MUrlLNDbK9QRg8VDJg0gOW\&index=4

Export the dataset as JSON, CSV, Excel, XML, RSS, or HTML. You can also run the Actor through the Apify API, schedule recurring snapshots, trigger webhooks, and connect results to supported Apify integrations.

#### ❓ FAQ

##### Do I need a Handshake account, institution access, or API key?

No. The Actor collects only anonymous public Handshake listings. It does not access institution-personalized results, saved jobs, applications, applicant data, or private account pages.

##### Can I submit a Handshake search URL or a single job URL?

Yes. `startUrls` accepts public Handshake search-result URLs and individual public job URLs. You can combine them with keyword discovery in the same run.

##### Why did a filter exclude a job with no published value?

Date, workplace, employment-type, and compensation filters require comparable public source data. A listing without the value needed for a selected filter is excluded rather than guessed.

##### Are duplicate jobs returned or charged twice?

No. The Actor uses canonical Handshake job identity to deduplicate the same job across all sources in a run. Only a unique successful listing saved to the default dataset creates the job charge.

##### Does `maxDiscoveryItems` limit direct job URLs?

No. It limits jobs returned from keywords, locations, and public search URLs. Direct job URLs are bounded by the submitted URL list itself.

##### Can this Actor alert me when a job changes or expires?

The Actor produces repeatable snapshots but does not keep cross-run state or generate change alerts itself. Schedule runs and compare canonical job IDs and fields in your own datastore or workflow.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~handshake-jobs-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Related Actors

- [Welcome to the Jungle Jobs Scraper](https://apify.com/maximedupre/welcometothejungle-jobs-extractor) — collect public WTTJ jobs across English and French markets.
- [Rozee.pk Jobs Scraper](https://apify.com/maximedupre/rozee-pk-jobs-scraper) — research public job listings in Pakistan by keyword, city, or URL.
- [CutShort Scraper](https://apify.com/maximedupre/cutshort-scraper) — analyze public Indian tech and startup roles, skills, and salaries.
- [CWjobs Scraper](https://apify.com/maximedupre/cwjobs-scraper) — monitor public UK technology jobs and salary signals.
- [Jobsite Scraper](https://apify.com/maximedupre/jobsite-scraper) — collect broader public UK job listings with search and apply context.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `keywords` (type: `array`):

Job titles, skills, or terms to find in public Handshake listings. Add multiple values to broaden discovery.

## `locations` (type: `array`):

Cities, regions, countries, or other location terms to match.

## `startUrls` (type: `array`):

Public Handshake search-result or individual job URLs. Search filters already present in a URL are preserved.

## `employers` (type: `array`):

Employer names to include. Leave empty to include jobs from any employer.

## `employmentTypes` (type: `array`):

Employment classifications to include, such as full-time, part-time, internship, or co-op. Leave empty to include every available classification.

## `workplace` (type: `string`):

Choose whether to include jobs of any workplace status or only jobs explicitly published as remote or on-site.

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

Include jobs posted within this many days. Leave unset to include any posting date.

## `compensationFilter` (type: `object`):

Optional published-pay threshold. Enter an amount, ISO 4217 currency code, and cadence; jobs without comparable published compensation are excluded.

## `maxDiscoveryItems` (type: `integer`):

Maximum unique matching jobs to return from keyword, location, and search-URL discovery. The Actor keeps searching past duplicates, filtered listings, and unavailable jobs until this limit is reached or discovery sources are exhausted; submitted individual job URLs remain bounded by that list itself.

## Actor input object example

```json
{
  "keywords": [
    "software engineer"
  ],
  "locations": [],
  "startUrls": [],
  "employers": [],
  "employmentTypes": [],
  "workplace": "any",
  "maxDiscoveryItems": 10
}
```

# Actor output Schema

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

Open successful unique public Handshake job listings in the default dataset.

# 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"
    ],
    "locations": [],
    "startUrls": [],
    "employers": [],
    "employmentTypes": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/handshake-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 = {
    "keywords": ["software engineer"],
    "locations": [],
    "startUrls": [],
    "employers": [],
    "employmentTypes": [],
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/handshake-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 '{
  "keywords": [
    "software engineer"
  ],
  "locations": [],
  "startUrls": [],
  "employers": [],
  "employmentTypes": []
}' |
apify call maximedupre/handshake-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Handshake Jobs Scraper",
        "description": "Collect anonymous public Handshake jobs by keyword, location, search URL, or job URL. Export employer, classification, compensation, dates, and full descriptions.",
        "version": "0.1",
        "x-build-id": "hGFzDv1katinXVwCy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~handshake-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-handshake-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/maximedupre~handshake-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-handshake-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/maximedupre~handshake-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-handshake-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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Job titles, skills, or terms to find in public Handshake listings. Add multiple values to broaden discovery.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": [
                            "software engineer"
                        ]
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities, regions, countries, or other location terms to match.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "startUrls": {
                        "title": "Handshake URLs",
                        "type": "array",
                        "description": "Public Handshake search-result or individual job URLs. Search filters already present in a URL are preserved.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "A public Handshake search-result or individual job URL.",
                                    "minLength": 1
                                }
                            },
                            "required": [
                                "url"
                            ],
                            "additionalProperties": false
                        }
                    },
                    "employers": {
                        "title": "Employers",
                        "type": "array",
                        "description": "Employer names to include. Leave empty to include jobs from any employer.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "employmentTypes": {
                        "title": "Employment types",
                        "type": "array",
                        "description": "Employment classifications to include, such as full-time, part-time, internship, or co-op. Leave empty to include every available classification.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "workplace": {
                        "title": "Workplace",
                        "enum": [
                            "any",
                            "remote",
                            "on-site"
                        ],
                        "type": "string",
                        "description": "Choose whether to include jobs of any workplace status or only jobs explicitly published as remote or on-site.",
                        "default": "any"
                    },
                    "postedWithinDays": {
                        "title": "Posted within",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Include jobs posted within this many days. Leave unset to include any posting date."
                    },
                    "compensationFilter": {
                        "title": "Minimum published compensation",
                        "required": [
                            "amount",
                            "currency",
                            "cadence"
                        ],
                        "type": "object",
                        "description": "Optional published-pay threshold. Enter an amount, ISO 4217 currency code, and cadence; jobs without comparable published compensation are excluded.",
                        "properties": {
                            "amount": {
                                "type": "number",
                                "title": "Minimum amount",
                                "description": "Lowest published compensation amount to include for the selected cadence and currency.",
                                "minimum": 0
                            },
                            "currency": {
                                "type": "string",
                                "title": "Currency",
                                "description": "Three-letter ISO 4217 currency code, such as USD, EUR, or GBP.",
                                "pattern": "^[A-Z]{3}$",
                                "minLength": 3,
                                "maxLength": 3
                            },
                            "cadence": {
                                "type": "string",
                                "title": "Cadence",
                                "description": "Pay period used for the minimum amount.",
                                "enum": [
                                    "hour",
                                    "day",
                                    "week",
                                    "month",
                                    "year"
                                ],
                                "enumTitles": [
                                    "Per hour",
                                    "Per day",
                                    "Per week",
                                    "Per month",
                                    "Per year"
                                ]
                            }
                        },
                        "additionalProperties": false
                    },
                    "maxDiscoveryItems": {
                        "title": "Maximum discovered jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum unique matching jobs to return from keyword, location, and search-URL discovery. The Actor keeps searching past duplicates, filtered listings, and unavailable jobs until this limit is reached or discovery sources are exhausted; submitted individual job URLs remain bounded by that list itself.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
