# Greenhouse, Lever & Ashby Jobs Scraper API (`rtworule/public-ats-job-feed-normalizer`) Actor

Normalize public Greenhouse, Lever, and Ashby jobs into one dataset. Detect official career URLs and optionally emit only new postings across scheduled runs.

- **URL**: https://apify.com/rtworule/public-ats-job-feed-normalizer.md
- **Developed by:** [Kunteper Koyu](https://apify.com/rtworule) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 job normalizeds

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, Lever & Ashby Jobs Scraper API

Fetch published job postings from official public Greenhouse, Lever, and Ashby endpoints and normalize them into one stable schema. Build job boards, hiring-signal datasets, market research, alerts, and recruiting automations without maintaining three provider-specific integrations.

### What you get

- company, title, primary and secondary locations, department, and team
- employment type, workplace type, and remote status when available
- plain-text and HTML descriptions
- canonical job and application URLs
- compensation when the provider exposes it
- publication and update timestamps
- deterministic SHA-256 fingerprints for change detection
- careers-URL auto-detection for supported provider URL formats
- persistent `newOnly` mode for scheduled monitors
- isolated board errors, so one invalid board does not discard successful results

### Common use cases

- power a niche job board or searchable jobs API
- monitor target companies for hiring and expansion signals
- create role, keyword, location, and remote-job alerts
- normalize jobs before analytics, enrichment, or RAG ingestion
- track new and changed postings across multiple ATS providers

### Quick start

1. Find the board token in the company's public careers URL.
2. Add the provider, board name, and optional company display name.
3. Add keyword, location, remote, or publication-date filters if needed.
4. Run the Actor and open the normalized dataset.

```json
{
  "boards": [
    {
      "provider": "greenhouse",
      "boardName": "anthropic",
      "companyName": "Anthropic"
    },
    {
      "provider": "lever",
      "boardName": "leverdemo",
      "companyName": "Lever",
      "region": "global"
    },
    {
      "provider": "ashby",
      "boardName": "Ashby",
      "companyName": "Ashby"
    }
  ],
  "searchTerms": ["engineer"],
  "locations": ["remote", "New York"],
  "remoteOnly": false,
  "includeDescription": true,
  "includeCompensation": true,
  "publishedAfter": "2026-07-01",
  "maxJobsPerBoard": 1000,
  "concurrency": 5,
  "timeoutSeconds": 30
}
````

Lever supports `global` and `eu` regions. Board names are the public token or site name in the provider's careers URL.

Alternatively, paste official hosted careers URLs and let the Actor identify
the provider and board without crawling the page:

```json
{
  "careerUrls": [
    "https://boards.greenhouse.io/example",
    "https://jobs.eu.lever.co/example",
    "https://jobs.ashbyhq.com/example"
  ],
  "newOnly": true,
  "stateStoreName": "my-daily-job-monitor"
}
```

Auto-detection is deliberately limited to `boards.greenhouse.io`,
`job-boards.greenhouse.io`, `jobs.lever.co`, `jobs.eu.lever.co`, and
`jobs.ashbyhq.com`. It parses the URL locally and calls the provider's public
JSON API; it does not scrape arbitrary company careers domains or follow
redirects. For a custom careers domain, use its official hosted ATS link or
enter the provider and board token under `boards`.

#### New-jobs-only scheduled runs

Set `newOnly` to `true` to persist stable hashes of provider, board, and source
job ID in the named `stateStoreName`. The first run emits all matching jobs;
later runs using the same store emit and charge only for previously unseen job
IDs. Edits to a known posting do not make it new. Use a separate store name for
each independent monitor and avoid concurrent runs against the same store,
because key-value-store updates are not transactional. State retains the most
recent 100,000 job identities. The default `newOnly: false` preserves the
original behavior.

### Example result

```json
{
  "provider": "greenhouse",
  "boardName": "anthropic",
  "companyName": "Anthropic",
  "sourceJobId": "4461450008",
  "title": "Account Executive, AI Native",
  "location": "San Francisco, CA | New York City, NY",
  "secondaryLocations": [],
  "remote": false,
  "jobUrl": "https://job-boards.greenhouse.io/anthropic/jobs/4461450008",
  "publishedAt": "2024-12-20T13:53:38-05:00",
  "updatedAt": "2026-06-08T20:49:32-04:00",
  "fingerprint": "cb3e2724e0fde508046d496236f32f598457dc566625918c48655cc80e836697",
  "retrievedAt": "2026-07-06T17:33:19.395Z"
}
```

### Run by API

Set `APIFY_TOKEN` in your environment and keep it out of source control.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/rtworule~public-ats-job-feed-normalizer/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"boards":[{"provider":"greenhouse","boardName":"anthropic","companyName":"Anthropic"}],"remoteOnly":true,"maxJobsPerBoard":100}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('rtworule/public-ats-job-feed-normalizer').call({
  boards: [{ provider: 'greenhouse', boardName: 'anthropic', companyName: 'Anthropic' }],
  remoteOnly: true,
  maxJobsPerBoard: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("rtworule/public-ats-job-feed-normalizer").call(run_input={
    "boards": [{
        "provider": "greenhouse",
        "boardName": "anthropic",
        "companyName": "Anthropic",
    }],
    "remoteOnly": True,
    "maxJobsPerBoard": 100,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Pricing

This Actor uses pay per event. A `job-normalized` event costs **$0.001 per stored job**: 100 delivered jobs cost $0.10 and 1,000 cost $1.00 in event charges. Apify applies a **$0.01 minimum run charge**. Filters, per-board limits, and `newOnly` mode help control output; the Actor stops storing results when the run's maximum total charge is reached. In `newOnly` mode, remembered postings are not emitted or charged as result events.

### Integrations and automation

- schedule with `newOnly: true` to receive and pay for only newly discovered jobs
- compare the output `fingerprint` separately when you want to detect edits to known jobs
- send matching jobs to Slack, email, Make, Zapier, n8n, or a webhook
- load normalized jobs into a database, search engine, BI tool, or vector store
- export CSV/XLSX to Sheets for research and editorial review
- use `publishedAfter`, search terms, and locations to keep recurring runs focused

### FAQ and troubleshooting

**Is this scraping private candidate or recruiting data?** No. It reads only public job-posting endpoints and does not access candidates, applications, internal postings, or authenticated recruiter systems.

**Where do I find the board name?** It is the company-specific token in the public Greenhouse, Lever, or Ashby careers URL—not necessarily the company's display name.

**Why is a job or field missing?** Filters may exclude it, the provider may omit the field, or the posting may have been removed. The Actor does not invent missing source data.

**How do I avoid duplicate alerts?** Enable `newOnly` and reuse the same
`stateStoreName` on every scheduled run. The Actor then suppresses previously
seen job IDs before charging or writing output. Keep `newOnly` disabled if you
want a full snapshot and compare the output `fingerprint` in your destination
to detect changed postings.

**Why did one board fail while the run succeeded?** Boards are isolated. Inspect the `BOARD_ERRORS` key-value-store record for an invalid token, provider response, timeout, or other board-specific error.

### Data sources, responsible use, and limitations

The Actor uses public posting endpoints:

- Greenhouse Job Board API: `https://boards-api.greenhouse.io/v1/boards/{board}/jobs`
- Lever Postings API: `https://api.lever.co/v0/postings/{site}`
- Ashby Job Postings API: `https://api.ashbyhq.com/posting-api/job-board/{board}`

Provider schemas, availability, and job content can change. Compensation, remote status, and timestamps are returned only when the source exposes enough information. Users remain responsible for their downstream use, retention, applicable terms, and compliance.

For a reproducible issue, open an issue from the Actor page with the run ID, provider, public board name, and expected behavior. Never include credentials, candidate data, or other sensitive information.

### More tools from this developer

- [RSS to JSON API — RSS, Atom & JSON Feed Parser](https://apify.com/rtworule/public-feed-normalizer)
- [Bulk URL Status Checker & Redirect Audit](https://apify.com/rtworule/bulk-url-health-auditor)
- [Website Tech Stack Detector](https://apify.com/rtworule/bulk-website-tech-detector)
- [AI Search Readiness / GEO & AEO Auditor](https://apify.com/rtworule/ai-search-readiness-auditor)

# Actor input Schema

## `boards` (type: `array`):

Public ATS boards to retrieve.

## `careerUrls` (type: `array`):

Optional official Greenhouse, Lever, or Ashby careers URLs. Provider and board name are detected from the URL without crawling the site.

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

Keep jobs whose title, description, company, department, or team contains at least one term. Empty means all jobs.

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

Keep jobs whose primary or secondary location contains at least one value. Empty means all locations.

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

Keep only jobs identified as remote by the source or location text.

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

Return plain-text and HTML descriptions. Disabling this reduces payload size.

## `includeCompensation` (type: `boolean`):

Request compensation from providers that expose it.

## `publishedAfter` (type: `string`):

Optional ISO date or timestamp. Jobs without a published timestamp are retained.

## `maxJobsPerBoard` (type: `integer`):

Maximum matching jobs stored from each board.

## `concurrency` (type: `integer`):

Number of job boards fetched in parallel.

## `timeoutSeconds` (type: `integer`):

Maximum seconds for each provider request.

## `newOnly` (type: `boolean`):

When enabled, persist job identity fingerprints and output/charge only postings not seen in earlier runs using the same state store.

## `stateStoreName` (type: `string`):

Named key-value store used to retain seen-job fingerprints across scheduled runs. Use the same name for one monitoring stream.

## Actor input object example

```json
{
  "boards": [
    {
      "provider": "greenhouse",
      "boardName": "anthropic",
      "companyName": "Anthropic"
    },
    {
      "provider": "ashby",
      "boardName": "Ashby",
      "companyName": "Ashby"
    }
  ],
  "careerUrls": [],
  "searchTerms": [],
  "locations": [],
  "remoteOnly": false,
  "includeDescription": true,
  "includeCompensation": true,
  "publishedAfter": "",
  "maxJobsPerBoard": 1000,
  "concurrency": 5,
  "timeoutSeconds": 30,
  "newOnly": false,
  "stateStoreName": "public-ats-job-feed-normalizer-state"
}
```

# Actor output Schema

## `jobs` (type: `string`):

No description

## `boardErrors` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("rtworule/public-ats-job-feed-normalizer").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("rtworule/public-ats-job-feed-normalizer").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 '{}' |
apify call rtworule/public-ats-job-feed-normalizer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=rtworule/public-ats-job-feed-normalizer",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Greenhouse, Lever & Ashby Jobs Scraper API",
        "description": "Normalize public Greenhouse, Lever, and Ashby jobs into one dataset. Detect official career URLs and optionally emit only new postings across scheduled runs.",
        "version": "0.1",
        "x-build-id": "Vbz5dQGiD9xQgvZrt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rtworule~public-ats-job-feed-normalizer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rtworule-public-ats-job-feed-normalizer",
                "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/rtworule~public-ats-job-feed-normalizer/runs": {
            "post": {
                "operationId": "runs-sync-rtworule-public-ats-job-feed-normalizer",
                "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/rtworule~public-ats-job-feed-normalizer/run-sync": {
            "post": {
                "operationId": "run-sync-rtworule-public-ats-job-feed-normalizer",
                "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": {
                    "boards": {
                        "title": "Job boards",
                        "type": "array",
                        "description": "Public ATS boards to retrieve.",
                        "default": [
                            {
                                "provider": "greenhouse",
                                "boardName": "anthropic",
                                "companyName": "Anthropic"
                            },
                            {
                                "provider": "ashby",
                                "boardName": "Ashby",
                                "companyName": "Ashby"
                            }
                        ]
                    },
                    "careerUrls": {
                        "title": "Public careers URLs (auto-detect)",
                        "type": "array",
                        "description": "Optional official Greenhouse, Lever, or Ashby careers URLs. Provider and board name are detected from the URL without crawling the site.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keep jobs whose title, description, company, department, or team contains at least one term. Empty means all jobs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Keep jobs whose primary or secondary location contains at least one value. Empty means all locations.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "remoteOnly": {
                        "title": "Remote jobs only",
                        "type": "boolean",
                        "description": "Keep only jobs identified as remote by the source or location text.",
                        "default": false
                    },
                    "includeDescription": {
                        "title": "Include descriptions",
                        "type": "boolean",
                        "description": "Return plain-text and HTML descriptions. Disabling this reduces payload size.",
                        "default": true
                    },
                    "includeCompensation": {
                        "title": "Include compensation",
                        "type": "boolean",
                        "description": "Request compensation from providers that expose it.",
                        "default": true
                    },
                    "publishedAfter": {
                        "title": "Published after",
                        "type": "string",
                        "description": "Optional ISO date or timestamp. Jobs without a published timestamp are retained.",
                        "default": ""
                    },
                    "maxJobsPerBoard": {
                        "title": "Maximum jobs per board",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum matching jobs stored from each board.",
                        "default": 1000
                    },
                    "concurrency": {
                        "title": "Board concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of job boards fetched in parallel.",
                        "default": 5
                    },
                    "timeoutSeconds": {
                        "title": "Request timeout",
                        "minimum": 1,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Maximum seconds for each provider request.",
                        "default": 30
                    },
                    "newOnly": {
                        "title": "Output new jobs only",
                        "type": "boolean",
                        "description": "When enabled, persist job identity fingerprints and output/charge only postings not seen in earlier runs using the same state store.",
                        "default": false
                    },
                    "stateStoreName": {
                        "title": "Incremental state store",
                        "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]*$",
                        "minLength": 1,
                        "maxLength": 63,
                        "type": "string",
                        "description": "Named key-value store used to retain seen-job fingerprints across scheduled runs. Use the same name for one monitoring stream.",
                        "default": "public-ats-job-feed-normalizer-state"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```