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

Scrape public Greenhouse job boards by token or URL. Export job titles, locations, departments, dates, metadata, descriptions, and application links.

- **URL**: https://apify.com/fetch\_cat/greenhouse-jobs-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 result extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Greenhouse Jobs Scraper

Scrape public Greenhouse job boards and export clean job-opening data from companies that use Greenhouse for hiring.

Use this actor when you need current roles, locations, departments, application links, posting dates, requisition IDs, custom metadata, and optional full job description HTML from public Greenhouse boards.

### Job data workflow

Use [LinkedIn Jobs Scraper](https://apify.com/fetch_cat/linkedin-jobs-scraper) for marketplace job postings by keyword and location.

Use [Workday Jobs Scraper](https://apify.com/fetch_cat/workday-jobs-scraper) and [Greenhouse Jobs Scraper](https://apify.com/fetch_cat/greenhouse-jobs-scraper) for company ATS boards.

Join outputs by company, title, location, and job URL to build recruiting research, hiring-signal, and labor-market datasets.

### What does Greenhouse Jobs Scraper do?

Greenhouse Jobs Scraper collects job openings from public Greenhouse-hosted career boards.

It accepts either board tokens, such as `airbnb`, or board URLs, such as `https://boards.greenhouse.io/airbnb`.

The actor returns one dataset item per job.

Each item includes the job title, company name, location, departments, offices, Greenhouse job URL, timestamps, requisition identifiers, metadata, and scrape timestamp.

You can also include the full job description HTML for enrichment, search indexing, or downstream parsing.

### Who is it for?

Recruiters use this scraper to monitor hiring activity at target companies.

Talent intelligence teams use it to build competitive hiring dashboards.

Lead generation teams use it to identify companies and teams that are growing.

Job-market analysts use it to track role volume by department, location, and date.

Sales teams use it to find hiring signals before outreach.

Developers use it to feed job data into warehouses, CRMs, BI tools, and internal workflows.

### Why use this actor?

✅ Simple inputs: use board tokens or board URLs.

✅ Fast HTTP runs: no browser automation is required for public Greenhouse boards.

✅ Clean output: normalized fields are ready for exports and APIs.

✅ Optional descriptions: include or skip full HTML content depending on your use case.

✅ Filters: narrow results by department and location.

✅ Multiple boards: scrape many Greenhouse boards in one run.

✅ Low-cost design: lightweight requests keep test runs inexpensive.

### Example use cases

Track all open jobs at a list of target accounts.

Monitor engineering hiring by company.

Build a weekly alert for new sales or customer success roles.

Collect job description text for keyword analysis.

Compare hiring by city, country, or remote status.

Enrich company lead lists with current hiring signals.

Export Greenhouse jobs to Google Sheets or BigQuery.

### Input overview

You can provide board tokens, board URLs, or both.

If both are provided, the actor deduplicates board tokens before scraping.

A board token is the part after `boards.greenhouse.io/`.

For example, `https://boards.greenhouse.io/airbnb` uses the token `airbnb`.

### Input fields

| Field | Type | Description |
| --- | --- | --- |
| `boardTokens` | array | Greenhouse board tokens such as `airbnb`, `okta`, or `discord`. |
| `boardUrls` | array | Public Greenhouse board URLs. The actor extracts tokens automatically. |
| `includeContent` | boolean | Include full job description HTML as `descriptionHtml`. |
| `department` | string | Optional case-insensitive department filter. |
| `location` | string | Optional case-insensitive location filter. |
| `limit` | integer | Maximum jobs to save across all boards. |
| `proxyConfiguration` | object | Optional proxy settings. Usually not needed. |

### Example input

```json
{
  "boardTokens": ["airbnb", "discord"],
  "includeContent": true,
  "limit": 100
}
````

### Example input with board URLs

```json
{
  "boardUrls": [
    { "url": "https://boards.greenhouse.io/airbnb" },
    { "url": "https://boards.greenhouse.io/okta" }
  ],
  "includeContent": false,
  "limit": 50
}
```

### Example input with filters

```json
{
  "boardTokens": ["discord"],
  "department": "Engineering",
  "location": "San Francisco",
  "includeContent": true,
  "limit": 25
}
```

### Output data

The actor saves one item per Greenhouse job.

| Field | Description |
| --- | --- |
| `boardToken` | Greenhouse board token used for the request. |
| `companyName` | Company name returned by Greenhouse. |
| `jobId` | Public Greenhouse job ID. |
| `title` | Job title. |
| `location` | Primary job location. |
| `departments` | All department names returned for the job. |
| `department` | First department name for table-friendly exports. |
| `offices` | Office names returned for the job. |
| `absoluteUrl` | Public application or job detail URL. |
| `updatedAt` | Greenhouse updated timestamp. |
| `firstPublished` | First published timestamp when available. |
| `requisitionId` | Requisition ID when available. |
| `internalJobId` | Internal Greenhouse job ID when available. |
| `applicationDeadline` | Application deadline when available. |
| `language` | Job language code when available. |
| `descriptionHtml` | Full job description HTML when enabled. |
| `metadata` | Custom Greenhouse metadata fields as key-value pairs. |
| `scrapedAt` | Timestamp when the actor saved the job. |

### Example output

```json
{
  "boardToken": "airbnb",
  "companyName": "Airbnb",
  "jobId": 7995153,
  "title": "Acquisition Manager",
  "location": "Berlin, Germany",
  "departments": [],
  "department": null,
  "offices": [],
  "absoluteUrl": "https://careers.airbnb.com/positions/7995153?gh_jid=7995153",
  "updatedAt": "2026-06-10T08:50:56-04:00",
  "firstPublished": "2026-06-10T08:50:56-04:00",
  "requisitionId": "ONE",
  "internalJobId": 3468206,
  "applicationDeadline": null,
  "language": "en",
  "metadata": {
    "Workplace Type": "Hybrid"
  },
  "scrapedAt": "2026-06-15T20:40:14.391Z"
}
```

### How much does it cost to scrape Greenhouse jobs?

The actor uses pay-per-event pricing.

There is a $0.005 start charge per run and a tiered per-job charge for each saved dataset item.

The BRONZE per-job price is $0.000027257 per saved job, with lower prices on higher Apify tiers.

A small test run with a low `limit` is recommended before running a long list of boards.

Final platform pricing is shown on the Apify Store page before you start a run.

### Tips for best results

Use board tokens when you already know them.

Use board URLs when copying directly from a company careers page.

Keep `includeContent` enabled if you need full job descriptions.

Disable `includeContent` if you only need titles, URLs, locations, and timestamps.

Set a low `limit` for first tests.

Use department filters only when you know the company uses matching department names.

Use location filters for broad terms such as `Remote`, `London`, or `Germany`.

### Integrations

Export jobs to CSV for spreadsheet review.

Send dataset items to Google Sheets using Apify integrations.

Load JSON into BigQuery, Snowflake, or a data lake.

Connect the actor to Zapier or Make for hiring alerts.

Use webhooks to notify a Slack channel after each run.

Feed job descriptions into text classification or keyword extraction pipelines.

### API usage

You can run the actor from the Apify API, Apify Client, or command line.

Use the actor ID format shown on the Store page.

### Node.js example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('fetch_cat/greenhouse-jobs-scraper').call({
  boardTokens: ['airbnb'],
  includeContent: true,
  limit: 25,
});

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

### Python example

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('fetch_cat/greenhouse-jobs-scraper').call(run_input={
    'boardTokens': ['airbnb'],
    'includeContent': True,
    'limit': 25,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL example

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~greenhouse-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"boardTokens":["airbnb"],"includeContent":true,"limit":25}'
```

### MCP usage

Use Apify MCP Server to run this actor from AI tools that support MCP.

Claude Code users can connect the Apify MCP server and ask for Greenhouse hiring data.

Claude Desktop users can add Apify MCP in their MCP configuration.

Example MCP URL:

```text
https://mcp.apify.com/?tools=fetch_cat/greenhouse-jobs-scraper
```

Claude Code CLI setup:

```bash
claude mcp add apify-greenhouse-jobs "https://mcp.apify.com/?tools=fetch_cat/greenhouse-jobs-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-greenhouse-jobs": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/greenhouse-jobs-scraper"
    }
  }
}
```

Example prompts:

- "Run the Greenhouse Jobs Scraper for Airbnb and summarize engineering roles."
- "Get the latest Discord Greenhouse jobs and group them by department."
- "Find jobs from these Greenhouse boards that mention data engineering."

### FAQ and troubleshooting

If a board returns zero jobs, check that the board token is correct and publicly available.

If department filtering returns zero jobs, run once without the filter and inspect the exact department names.

If location filtering returns zero jobs, try a broader location term.

If you do not need descriptions, set `includeContent` to `false` to reduce output size.

### Limitations

The actor only collects public jobs from public Greenhouse boards.

It does not access private recruiter dashboards or applicant data.

It does not apply to jobs or submit forms.

Some companies use custom career pages that are not backed by a public Greenhouse board token.

### Legality and ethical use

This actor collects publicly available job posting data.

Use the data responsibly and comply with applicable laws, website terms, and privacy requirements.

Do not use the actor to collect personal applicant data.

Do not overload source websites with excessive schedules or unnecessary repeated runs.

### Related scrapers

Use this actor with other Anna recruiting and company-data scrapers as they become available.

Related actor links should use the official Anna Apify account once published.

### Changelog

Initial version supports public Greenhouse board tokens, board URLs, content toggle, department filters, location filters, and normalized job output.

### Support

If you need a field that is visible on public Greenhouse jobs but not included in the dataset, open an issue with an example board token and the field you need.

If a public board does not work, include the exact board URL and run ID so it can be reproduced.

### Quick start checklist

1. Open the actor input.

2. Enter one or more board tokens.

3. Keep the default low limit for the first run.

4. Run the actor.

5. Review the dataset table.

6. Increase the limit or add more boards when the output looks right.

### Field notes

`department` is a convenience field for tables.

`departments` preserves all department names returned by Greenhouse.

`metadata` preserves custom company-specific fields.

`descriptionHtml` is optional because job descriptions can be long.

`absoluteUrl` is the best link to use for users and downstream systems.

### Scheduling ideas

Run daily to monitor new roles at target accounts.

Run weekly to build historical hiring trends.

Run monthly to refresh company hiring snapshots.

Use webhooks after scheduled runs to update dashboards.

### Data quality checks

Check `jobId` for stable deduplication.

Check `updatedAt` for changed postings.

Check `firstPublished` for newly opened jobs.

Check `absoluteUrl` before sharing links externally.

Check custom `metadata` fields because every company can define them differently.

# Actor input Schema

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

Greenhouse board names such as airbnb, okta, or discord. For boards.greenhouse.io/airbnb, use airbnb.

## `boardUrls` (type: `array`):

Optional public Greenhouse board URLs. The actor extracts board tokens from these URLs.

## `includeContent` (type: `boolean`):

Return the full Greenhouse descriptionHtml field for each job.

## `department` (type: `string`):

Optional case-insensitive department name filter, for example Sales or Engineering.

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

Optional case-insensitive location filter, for example Remote, London, or France.

## `limit` (type: `integer`):

Maximum number of matching jobs to save across all boards.

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

Optional proxy settings. Greenhouse public boards usually work without a proxy.

## Actor input object example

```json
{
  "boardTokens": [
    "airbnb"
  ],
  "boardUrls": [
    {
      "url": "https://boards.greenhouse.io/airbnb"
    }
  ],
  "includeContent": true,
  "limit": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "boardTokens": [
        "airbnb"
    ],
    "boardUrls": [
        {
            "url": "https://boards.greenhouse.io/airbnb"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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": ["airbnb"],
    "boardUrls": [{ "url": "https://boards.greenhouse.io/airbnb" }],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/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": [
    "airbnb"
  ],
  "boardUrls": [
    {
      "url": "https://boards.greenhouse.io/airbnb"
    }
  ]
}' |
apify call fetch_cat/greenhouse-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Greenhouse Jobs Scraper",
        "description": "Scrape public Greenhouse job boards by token or URL. Export job titles, locations, departments, dates, metadata, descriptions, and application links.",
        "version": "0.1",
        "x-build-id": "pBbkdzNVLivpRDibx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~greenhouse-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-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/fetch_cat~greenhouse-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-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/fetch_cat~greenhouse-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-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": "Greenhouse board tokens",
                        "type": "array",
                        "description": "Greenhouse board names such as airbnb, okta, or discord. For boards.greenhouse.io/airbnb, use airbnb.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "boardUrls": {
                        "title": "Greenhouse board URLs",
                        "type": "array",
                        "description": "Optional public Greenhouse board URLs. The actor extracts board tokens from these URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "includeContent": {
                        "title": "Include job description HTML",
                        "type": "boolean",
                        "description": "Return the full Greenhouse descriptionHtml field for each job.",
                        "default": true
                    },
                    "department": {
                        "title": "Department filter",
                        "type": "string",
                        "description": "Optional case-insensitive department name filter, for example Sales or Engineering."
                    },
                    "location": {
                        "title": "Location filter",
                        "type": "string",
                        "description": "Optional case-insensitive location filter, for example Remote, London, or France."
                    },
                    "limit": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of matching jobs to save across all boards.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Greenhouse public boards usually work without a proxy.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```