# Greenhouse Jobs Scraper (`scrapeworks/greenhouse-jobs-scraper`) Actor

Scrape every open job from any company's Greenhouse careers board. Give it a list of company board tokens (e.g. stripe, databricks, airbnb) and get one clean row per job: title, company, department, location, salary range, apply URL and full description.

- **URL**: https://apify.com/scrapeworks/greenhouse-jobs-scraper.md
- **Developed by:** [Nicolas van Arkens](https://apify.com/scrapeworks) (community)
- **Categories:** Jobs, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Greenhouse Jobs Scraper — export every open role from any Greenhouse careers board

Pull **every open job** from any company that hosts its careers page on **Greenhouse** —
thousands of clean, structured rows in one run. Give the actor a list of **company board
tokens** (the slug in `boards.greenhouse.io/<token>`, e.g. `stripe`, `databricks`,
`airbnb`) and it returns one tidy row per job: title, company, department, location,
**disclosed salary range**, apply URL and the full job description.

No login, no API key, no browser. Greenhouse publishes a public Job Board API, so this
actor is fast and stable — it does not break when a page's layout changes.

### What you get (one row per job)

| Field | Description |
|---|---|
| `jobId` | Greenhouse job id (stable, unique) |
| `internalJobId` | Greenhouse internal job id |
| `title` | Job title |
| `company` | Company name |
| `boardToken` | The board this job came from (e.g. `stripe`) |
| `location` | Primary location text (e.g. "San Francisco, CA", "Remote") |
| `offices` | All office locations for the role |
| `department` | Primary department (e.g. "Engineering") |
| `departments` | All departments the role is filed under |
| `salaryMin`, `salaryMax` | Disclosed pay range (in dollars, not cents) |
| `salaryCurrency` | Currency of the pay range (USD, EUR, CAD, …) |
| `salaryPeriod` | `year` or `hour` |
| `payRanges` | Every pay zone with its own label/min/max (e.g. "Zone 1", "Zone 2") |
| `requisitionId` | Company requisition id |
| `absoluteUrl` | Direct link to apply / view the job |
| `firstPublished` | When the job was first posted |
| `updatedAt` | When the job was last updated |
| `applicationDeadline` | Deadline, when set |
| `language` | Posting language |
| `descriptionText` | Full job description as clean plain text |
| `descriptionHtml` | Full job description as HTML |
| `metadata` | Any custom fields the company attaches to the posting |
| `scrapedAt` | UTC timestamp of the scrape |

### Input

```json
{
  "boardTokens": ["stripe", "databricks", "airbnb", "figma"],
  "searchTerms": ["engineer", "data", "product"],
  "locationQuery": ["Remote", "New York"],
  "updatedAfter": "2026-06-01",
  "includeDescription": true,
  "maxResults": 5000
}
````

- **`boardTokens`** — the companies to scrape. Paste the bare token (`stripe`) **or** a
  full Greenhouse URL (`https://boards.greenhouse.io/stripe`,
  `https://job-boards.greenhouse.io/stripe/jobs/123`, or the
  `…/embed/job_board?for=stripe` link) — the token is extracted for you. One board can
  hold hundreds of jobs, so a handful of tokens returns thousands of rows. Jobs seen on
  more than one board are de-duplicated automatically.
- **`searchTerms`** *(optional)* — keep only jobs whose **title or department** contains
  any of these words. Leave empty to keep every job.
- **`locationQuery`** *(optional)* — keep only jobs whose **location/office** matches any
  of these (e.g. `Remote`, `London`, `United States`).
- **`updatedAfter`** *(optional)* — keep only jobs updated on/after this date
  (`YYYY-MM-DD`). Great for repeat runs that pull only fresh roles.
- **`includeDescription`** — include the full description (on by default). Turn off for a
  lighter listing-only dataset.
- **`maxResults`** — cap the number of jobs for the run (billed per row).

#### Finding a board token

Open a company's "See all jobs" / careers page. If the URL is
`boards.greenhouse.io/<something>` or `job-boards.greenhouse.io/<something>`, that
`<something>` is the token. Many companies embed a Greenhouse board on their own careers
site — view the "apply" link; if it points at `greenhouse.io`, the token is in that link.

### Output sample

```json
{
  "jobId": 5364702004,
  "title": "Staff Software Engineer, Payments",
  "company": "Figma",
  "boardToken": "figma",
  "location": "San Francisco, CA",
  "offices": ["San Francisco, CA", "New York, NY"],
  "department": "Engineering",
  "departments": ["Engineering"],
  "salaryMin": 165000,
  "salaryMax": 190000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "payRanges": [
    { "label": "Annual Base Salary Range:", "min": 165000, "max": 190000, "currency": "USD" }
  ],
  "requisitionId": "REQ-1234",
  "absoluteUrl": "https://boards.greenhouse.io/figma/jobs/5364702004",
  "firstPublished": "2026-06-02T08:58:57-04:00",
  "updatedAt": "2026-07-13T14:37:36-04:00",
  "language": "en",
  "descriptionText": "About the role\nFigma is looking for ...",
  "scrapedAt": "2026-07-20T12:00:00+00:00"
}
```

### Use cases

- **Recruiting & sourcing** — build a live, structured feed of open roles at the companies
  you care about, refreshed on a schedule.
- **Job boards & aggregators** — populate a niche job board from dozens of employers'
  Greenhouse boards without maintaining a scraper per company.
- **Market & compensation research** — track hiring volume, department mix and **disclosed
  salary ranges** across a set of companies over time.
- **Sales & recruiting intelligence** — spot which teams a company is scaling (e.g. a spike
  in "Sales" or "Data" roles) as a buying/hiring signal.

### FAQ

**Do I need a Greenhouse account or API key?** No. The actor uses Greenhouse's public Job
Board API. You only supply the company board tokens.

**How many jobs can I get?** Every open job on each board — one board can be hundreds of
roles, so a handful of tokens easily returns thousands. Use `maxResults` to cap a run.

**Why do some jobs have no salary?** Salary appears only when the company opts into pay
transparency on Greenhouse. Many US postings include it; others don't — those rows simply
have empty salary fields (they are still returned).

**Can I filter to just certain roles or locations?** Yes — `searchTerms` filters by title
or department, and `locationQuery` filters by location/office. Both are optional.

**Does it break when a careers page changes design?** No. It reads the structured Job
Board API, not the HTML page, so it is stable.

**How am I billed?** Pay per result — you are charged once for each job row returned.
Boards that don't exist or fail to load are skipped and never charged.

# Actor input Schema

## `boardTokens` (type: `array`):

The Greenhouse board tokens (company slugs) to scrape. A board token is the slug in a company's Greenhouse careers URL - e.g. for 'https://boards.greenhouse.io/stripe' the token is 'stripe'. You can paste either the bare token ('stripe', 'databricks') OR a full Greenhouse board URL (https://boards.greenhouse.io/<token>, https://job-boards.greenhouse.io/<token>/jobs, or the embed '...job\_board?for=<token>' link) and the token is extracted for you. One board can hold hundreds of jobs, so a handful of tokens returns thousands of rows. Duplicate jobs across boards are removed automatically. A company's own careers domain (e.g. 'stripe.com/jobs') does not contain the token - open its 'View all jobs' page to find the boards.greenhouse.io slug.

## `searchTerms` (type: `array`):

Optional. Keep only jobs whose title OR department contains any of these words (case-insensitive substring match). For example \['engineer', 'data', 'product'] pulls just the engineering/data/product roles across every board. Leave empty to keep EVERY open job on each board.

## `locationQuery` (type: `array`):

Optional. Keep only jobs whose location or office text contains any of these (case-insensitive substring) - e.g. \['New York', 'Remote', 'London', 'United States']. Leave empty to keep jobs in every location.

## `updatedAfter` (type: `string`):

Optional. Keep only jobs whose 'last updated' date is on or after this date (format YYYY-MM-DD, e.g. 2026-06-01). Useful for pulling only freshly-updated roles on a repeat run. Leave empty to keep jobs regardless of date.

## `includeDescription` (type: `boolean`):

If enabled (default), each row includes the full job description as both clean plain text (descriptionText) and HTML (descriptionHtml). Turn this off for a lighter, listing-only dataset (title, company, location, department, salary, apply URL) without the large description fields.

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

Maximum number of unique jobs to return for the whole run (across all boards, after removing duplicates). Results are billed per job row. The default board list holds roughly 4,000 live jobs, so lower this to cap cost on a test run.

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

Proxy used to reach the Greenhouse Job Board API. The actor fetches directly first (cheapest) and only falls back to this proxy, rotating to a fresh session, if a response comes back blocked. The default (Apify Residential, US) is a safe fallback and is rarely needed - the public API answers plain requests.

## Actor input object example

```json
{
  "boardTokens": [
    "stripe",
    "databricks",
    "airbnb",
    "figma"
  ],
  "searchTerms": [
    "engineer",
    "data",
    "product",
    "designer"
  ],
  "locationQuery": [
    "Remote",
    "New York",
    "London"
  ],
  "updatedAfter": "2026-06-01",
  "includeDescription": true,
  "maxResults": 5000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "boardTokens": [
        "stripe",
        "databricks",
        "coinbase",
        "airbnb",
        "figma",
        "gitlab",
        "cloudflare",
        "reddit",
        "anthropic",
        "samsara",
        "robinhood",
        "instacart",
        "asana",
        "brex",
        "affirm",
        "discord",
        "twitch",
        "gusto",
        "dropbox",
        "gemini"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeworks/greenhouse-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 = {
    "boardTokens": [
        "stripe",
        "databricks",
        "coinbase",
        "airbnb",
        "figma",
        "gitlab",
        "cloudflare",
        "reddit",
        "anthropic",
        "samsara",
        "robinhood",
        "instacart",
        "asana",
        "brex",
        "affirm",
        "discord",
        "twitch",
        "gusto",
        "dropbox",
        "gemini",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeworks/greenhouse-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 '{
  "boardTokens": [
    "stripe",
    "databricks",
    "coinbase",
    "airbnb",
    "figma",
    "gitlab",
    "cloudflare",
    "reddit",
    "anthropic",
    "samsara",
    "robinhood",
    "instacart",
    "asana",
    "brex",
    "affirm",
    "discord",
    "twitch",
    "gusto",
    "dropbox",
    "gemini"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call scrapeworks/greenhouse-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Greenhouse Jobs Scraper",
        "description": "Scrape every open job from any company's Greenhouse careers board. Give it a list of company board tokens (e.g. stripe, databricks, airbnb) and get one clean row per job: title, company, department, location, salary range, apply URL and full description.",
        "version": "0.1",
        "x-build-id": "u9uR6nPvER55UzkON"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeworks~greenhouse-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeworks-greenhouse-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/scrapeworks~greenhouse-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeworks-greenhouse-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/scrapeworks~greenhouse-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeworks-greenhouse-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": {
                    "boardTokens": {
                        "title": "Company board tokens",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "The Greenhouse board tokens (company slugs) to scrape. A board token is the slug in a company's Greenhouse careers URL - e.g. for 'https://boards.greenhouse.io/stripe' the token is 'stripe'. You can paste either the bare token ('stripe', 'databricks') OR a full Greenhouse board URL (https://boards.greenhouse.io/<token>, https://job-boards.greenhouse.io/<token>/jobs, or the embed '...job_board?for=<token>' link) and the token is extracted for you. One board can hold hundreds of jobs, so a handful of tokens returns thousands of rows. Duplicate jobs across boards are removed automatically. A company's own careers domain (e.g. 'stripe.com/jobs') does not contain the token - open its 'View all jobs' page to find the boards.greenhouse.io slug.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Keyword filter (optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional. Keep only jobs whose title OR department contains any of these words (case-insensitive substring match). For example ['engineer', 'data', 'product'] pulls just the engineering/data/product roles across every board. Leave empty to keep EVERY open job on each board.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationQuery": {
                        "title": "Location filter (optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional. Keep only jobs whose location or office text contains any of these (case-insensitive substring) - e.g. ['New York', 'Remote', 'London', 'United States']. Leave empty to keep jobs in every location.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "updatedAfter": {
                        "title": "Updated on/after (optional)",
                        "type": "string",
                        "description": "Optional. Keep only jobs whose 'last updated' date is on or after this date (format YYYY-MM-DD, e.g. 2026-06-01). Useful for pulling only freshly-updated roles on a repeat run. Leave empty to keep jobs regardless of date."
                    },
                    "includeDescription": {
                        "title": "Include full job description",
                        "type": "boolean",
                        "description": "If enabled (default), each row includes the full job description as both clean plain text (descriptionText) and HTML (descriptionHtml). Turn this off for a lighter, listing-only dataset (title, company, location, department, salary, apply URL) without the large description fields.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of unique jobs to return for the whole run (across all boards, after removing duplicates). Results are billed per job row. The default board list holds roughly 4,000 live jobs, so lower this to cap cost on a test run.",
                        "default": 5000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to reach the Greenhouse Job Board API. The actor fetches directly first (cheapest) and only falls back to this proxy, rotating to a fresh session, if a response comes back blocked. The default (Apify Residential, US) is a safe fallback and is rarely needed - the public API answers plain requests.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
