# ATS Jobs Aggregator - Greenhouse, Lever & Ashby Jobs (`benthepythondev/ats-jobs-aggregator`) Actor

Aggregate live job postings from company career pages across Greenhouse, Lever and Ashby ATS in one run. No API key. Filter by keyword, location and remote.

- **URL**: https://apify.com/benthepythondev/ats-jobs-aggregator.md
- **Developed by:** [ben](https://apify.com/benthepythondev) (community)
- **Categories:** Jobs, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## ATS Jobs Aggregator — Greenhouse, Lever, Ashby, SmartRecruiters & Recruitee in One Run

Aggregate **live job postings straight from company career pages** across five
major Applicant Tracking Systems — **Greenhouse, Lever, Ashby, SmartRecruiters,
and Recruitee** — in a single run. Instead of scraping one job board at a time,
this Actor pulls openings directly from the source companies post to, so you get
fresh, first-party listings with apply links that actually work. No API key, no
login, no proxy.

### Quick start

Click **Run**. With zero configuration it returns thousands of current openings
from a curated set of well-known tech companies across all three ATS platforms.
Then narrow down with keyword, location, or remote-only filters, or swap in your
own list of company slugs.

### Why scrape jobs from ATS platforms?

Most job-board scrapers hit aggregator sites that are already stale, deduplicated
poorly, or blocked behind anti-bot walls. Greenhouse, Lever, Ashby,
SmartRecruiters, and Recruitee expose **public JSON endpoints** that companies
themselves publish — the same data that powers their careers pages. That means:

- **Fresh, first-party data** — postings appear here the moment a company opens them.
- **Working apply links** — every job links to the real application page.
- **No blocking** — public APIs, so runs are fast and reliable (no browser, no proxy).
- **Normalized across sources** — one consistent schema whether a job came from
  Greenhouse, Lever, or Ashby.

### Features

- **Scrape jobs from Greenhouse, Lever, Ashby, SmartRecruiters, and Recruitee** in one run
- **Aggregate openings across 30+ companies** out of the box (fully customizable)
- **Filter jobs by keyword** (e.g. "engineer", "product", "sales")
- **Filter jobs by location** (e.g. "Berlin", "New York", "United States")
- **Get remote-only jobs** with a single toggle
- **Export job title, company, location, department, employment type and apply URL**
- **Optional full job descriptions** for AI/LLM and matching use cases
- **Automatic de-duplication** by apply URL

### Input

| Field | Type | Description |
|-------|------|-------------|
| `sources` | array | Which ATS to query: `greenhouse`, `lever`, `ashby` (default: all) |
| `greenhouseCompanies` | array | Greenhouse board tokens (defaults to a curated list) |
| `leverCompanies` | array | Lever company slugs (defaults to a curated list) |
| `ashbyCompanies` | array | Ashby job-board names (defaults to a curated list) |
| `keywords` | array | Keep only jobs whose title contains any keyword |
| `location` | string | Keep only jobs whose location contains this text |
| `remoteOnly` | boolean | Keep only remote jobs |
| `includeDescription` | boolean | Include full job description text |
| `maxResults` | integer | Maximum jobs to return (default 200) |

#### Example input

```json
{
  "sources": ["greenhouse", "lever", "ashby"],
  "keywords": ["engineer", "data"],
  "remoteOnly": true,
  "maxResults": 500
}
````

### Output

Each item is a normalized job posting:

```json
{
  "source": "ashby",
  "company": "notion",
  "job_title": "Senior Software Engineer, Data",
  "company_name": "notion",
  "location": "San Francisco, CA",
  "department": "Engineering",
  "team": "Data",
  "employment_type": "FullTime",
  "remote": true,
  "job_url": "https://jobs.ashbyhq.com/notion/...",
  "posted_at": "2026-05-30T12:00:00Z",
  "scraped_at": "2026-06-20T09:00:00Z"
}
```

### Use cases

- **Job boards & aggregators** — power a niche or regional job site with fresh, first-party listings.
- **Recruiting & sourcing** — track who is hiring for a role across dozens of companies at once.
- **Market & talent intelligence** — monitor hiring trends, team growth, and locations by company.
- **AI job matching** — feed normalized postings (with descriptions) into matching or recommendation models.
- **Sales prospecting** — companies hiring for a role often signal budget and growth; use openings as buying signals.

### How it compares

Single-ATS scrapers make you run and stitch together three different tools. This
Actor aggregates **Greenhouse + Lever + Ashby** into one normalized dataset, so
you query every company's career page in one place — and it's trivial to add your
own company slugs to track exactly the employers you care about.

### Pricing

Pay-per-result usage-based pricing — you only pay for the jobs you actually get.
Runs are cheap because the Actor hits fast public APIs with no proxy costs.

### FAQ

**Do I need a Greenhouse, Lever, or Ashby API key?**
No. All three expose public job-board endpoints. No key, login, or token required.

**Can I track specific companies?**
Yes. Put their ATS slugs into `greenhouseCompanies`, `leverCompanies`, or
`ashbyCompanies`. The slug is the company identifier in their careers URL.

**How do I find a company's ATS slug?**
It's in their careers page URL — e.g. `boards.greenhouse.io/{slug}`,
`jobs.lever.co/{slug}`, `jobs.ashbyhq.com/{slug}`,
`jobs.smartrecruiters.com/{slug}`, or `{slug}.recruitee.com`.

**How fresh is the data?**
It's pulled live on every run, directly from each company's ATS — as fresh as
their own careers page.

**Can I get full job descriptions?**
Yes — enable `includeDescription`. Output is larger but ideal for AI matching,
search indexing, and analysis.

**Is web scraping legal?**
This Actor reads publicly available job data from official ATS endpoints. Use the
data responsibly and in line with applicable terms and laws.

***

**Keywords:** jobs scraper, ATS scraper, Greenhouse jobs API, Lever jobs scraper,
Ashby jobs API, job postings aggregator, careers page scraper, tech jobs data,
remote jobs scraper, hiring data, recruiting data, job board API.

# Actor input Schema

## `sources` (type: `array`):

Which Applicant Tracking Systems to pull jobs from.

## `greenhouseCompanies` (type: `array`):

Greenhouse board tokens (company slugs). Leave as-is to use a curated default list.

## `leverCompanies` (type: `array`):

Lever company slugs. Leave as-is to use a curated default list.

## `ashbyCompanies` (type: `array`):

Ashby job-board names. Leave as-is to use a curated default list.

## `smartrecruitersCompanies` (type: `array`):

SmartRecruiters company identifiers (case-sensitive). Leave as-is to use a curated default list.

## `recruiteeCompanies` (type: `array`):

Recruitee company subdomains. Leave as-is to use a curated default list.

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

Only keep jobs whose title contains any of these keywords (case-insensitive). Leave empty for all.

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

Only keep jobs whose location contains this text (e.g. 'Berlin', 'New York', 'United States').

## `remoteOnly` (type: `boolean`):

Only keep jobs flagged remote.

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

Include the full job description text (larger output).

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

Maximum number of jobs to return.

## Actor input object example

```json
{
  "sources": [
    "greenhouse",
    "lever",
    "ashby",
    "smartrecruiters",
    "recruitee"
  ],
  "greenhouseCompanies": [
    "airbnb",
    "stripe",
    "figma",
    "cloudflare",
    "coinbase",
    "databricks",
    "discord",
    "dropbox",
    "gitlab",
    "robinhood",
    "doordash",
    "instacart"
  ],
  "leverCompanies": [
    "openai",
    "anthropic",
    "anduril",
    "scale",
    "verkada",
    "rippling",
    "mistral",
    "includedhealth",
    "gohighlevel"
  ],
  "ashbyCompanies": [
    "notion",
    "vanta",
    "linear",
    "posthog",
    "ramp"
  ],
  "smartrecruitersCompanies": [
    "Visa",
    "WesternDigital",
    "PublicStorage"
  ],
  "recruiteeCompanies": [
    "bunq",
    "channable"
  ],
  "keywords": [
    "engineer"
  ],
  "location": "",
  "remoteOnly": false,
  "includeDescription": false,
  "maxResults": 200
}
```

# 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 = {
    "sources": [
        "greenhouse",
        "lever",
        "ashby",
        "smartrecruiters",
        "recruitee"
    ],
    "greenhouseCompanies": [
        "airbnb",
        "stripe",
        "figma",
        "cloudflare",
        "coinbase",
        "databricks",
        "discord",
        "dropbox",
        "gitlab",
        "robinhood",
        "doordash",
        "instacart"
    ],
    "leverCompanies": [
        "openai",
        "anthropic",
        "anduril",
        "scale",
        "verkada",
        "rippling",
        "mistral",
        "includedhealth",
        "gohighlevel"
    ],
    "ashbyCompanies": [
        "notion",
        "vanta",
        "linear",
        "posthog",
        "ramp"
    ],
    "smartrecruitersCompanies": [
        "Visa",
        "WesternDigital",
        "PublicStorage"
    ],
    "recruiteeCompanies": [
        "bunq",
        "channable"
    ],
    "keywords": [
        "engineer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/ats-jobs-aggregator").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 = {
    "sources": [
        "greenhouse",
        "lever",
        "ashby",
        "smartrecruiters",
        "recruitee",
    ],
    "greenhouseCompanies": [
        "airbnb",
        "stripe",
        "figma",
        "cloudflare",
        "coinbase",
        "databricks",
        "discord",
        "dropbox",
        "gitlab",
        "robinhood",
        "doordash",
        "instacart",
    ],
    "leverCompanies": [
        "openai",
        "anthropic",
        "anduril",
        "scale",
        "verkada",
        "rippling",
        "mistral",
        "includedhealth",
        "gohighlevel",
    ],
    "ashbyCompanies": [
        "notion",
        "vanta",
        "linear",
        "posthog",
        "ramp",
    ],
    "smartrecruitersCompanies": [
        "Visa",
        "WesternDigital",
        "PublicStorage",
    ],
    "recruiteeCompanies": [
        "bunq",
        "channable",
    ],
    "keywords": ["engineer"],
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/ats-jobs-aggregator").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 '{
  "sources": [
    "greenhouse",
    "lever",
    "ashby",
    "smartrecruiters",
    "recruitee"
  ],
  "greenhouseCompanies": [
    "airbnb",
    "stripe",
    "figma",
    "cloudflare",
    "coinbase",
    "databricks",
    "discord",
    "dropbox",
    "gitlab",
    "robinhood",
    "doordash",
    "instacart"
  ],
  "leverCompanies": [
    "openai",
    "anthropic",
    "anduril",
    "scale",
    "verkada",
    "rippling",
    "mistral",
    "includedhealth",
    "gohighlevel"
  ],
  "ashbyCompanies": [
    "notion",
    "vanta",
    "linear",
    "posthog",
    "ramp"
  ],
  "smartrecruitersCompanies": [
    "Visa",
    "WesternDigital",
    "PublicStorage"
  ],
  "recruiteeCompanies": [
    "bunq",
    "channable"
  ],
  "keywords": [
    "engineer"
  ]
}' |
apify call benthepythondev/ats-jobs-aggregator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ATS Jobs Aggregator - Greenhouse, Lever & Ashby Jobs",
        "description": "Aggregate live job postings from company career pages across Greenhouse, Lever and Ashby ATS in one run. No API key. Filter by keyword, location and remote.",
        "version": "0.1",
        "x-build-id": "WTt0DrL9twlxKkFFj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~ats-jobs-aggregator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-ats-jobs-aggregator",
                "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/benthepythondev~ats-jobs-aggregator/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-ats-jobs-aggregator",
                "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/benthepythondev~ats-jobs-aggregator/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-ats-jobs-aggregator",
                "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": {
                    "sources": {
                        "title": "ATS sources",
                        "type": "array",
                        "description": "Which Applicant Tracking Systems to pull jobs from.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "greenhouse",
                                "lever",
                                "ashby",
                                "smartrecruiters",
                                "recruitee"
                            ],
                            "enumTitles": [
                                "Greenhouse",
                                "Lever",
                                "Ashby",
                                "SmartRecruiters",
                                "Recruitee"
                            ]
                        },
                        "default": [
                            "greenhouse",
                            "lever",
                            "ashby",
                            "smartrecruiters",
                            "recruitee"
                        ]
                    },
                    "greenhouseCompanies": {
                        "title": "Greenhouse companies",
                        "type": "array",
                        "description": "Greenhouse board tokens (company slugs). Leave as-is to use a curated default list.",
                        "default": [
                            "airbnb",
                            "stripe",
                            "figma",
                            "cloudflare",
                            "coinbase",
                            "databricks",
                            "discord",
                            "dropbox",
                            "gitlab",
                            "robinhood",
                            "doordash",
                            "instacart"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "leverCompanies": {
                        "title": "Lever companies",
                        "type": "array",
                        "description": "Lever company slugs. Leave as-is to use a curated default list.",
                        "default": [
                            "openai",
                            "anthropic",
                            "anduril",
                            "scale",
                            "verkada",
                            "rippling",
                            "mistral",
                            "includedhealth",
                            "gohighlevel"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "ashbyCompanies": {
                        "title": "Ashby companies",
                        "type": "array",
                        "description": "Ashby job-board names. Leave as-is to use a curated default list.",
                        "default": [
                            "notion",
                            "vanta",
                            "linear",
                            "posthog",
                            "ramp"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "smartrecruitersCompanies": {
                        "title": "SmartRecruiters companies",
                        "type": "array",
                        "description": "SmartRecruiters company identifiers (case-sensitive). Leave as-is to use a curated default list.",
                        "default": [
                            "Visa",
                            "WesternDigital",
                            "PublicStorage"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "recruiteeCompanies": {
                        "title": "Recruitee companies",
                        "type": "array",
                        "description": "Recruitee company subdomains. Leave as-is to use a curated default list.",
                        "default": [
                            "bunq",
                            "channable"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keyword filter",
                        "type": "array",
                        "description": "Only keep jobs whose title contains any of these keywords (case-insensitive). Leave empty for all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location filter",
                        "type": "string",
                        "description": "Only keep jobs whose location contains this text (e.g. 'Berlin', 'New York', 'United States').",
                        "default": ""
                    },
                    "remoteOnly": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Only keep jobs flagged remote.",
                        "default": false
                    },
                    "includeDescription": {
                        "title": "Include full description",
                        "type": "boolean",
                        "description": "Include the full job description text (larger output).",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of jobs to return.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
