# Ashby Jobs Scraper (`fetch_cat/ashby-jobs-scraper`) Actor

Extract live jobs from public Ashby career boards with team, location, compensation, IDs, URLs, and optional full descriptions.

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

## Pricing

Pay per event

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

## Ashby Jobs Scraper

Extract live job postings from public Ashby company career boards.

Use this Actor to turn Ashby-hosted recruiting pages into clean, exportable job datasets for hiring intelligence, job-board operations, sales prospecting, and market research.

### What does Ashby Jobs Scraper do?

Ashby Jobs Scraper collects open roles from public Ashby job boards such as `openai`, `ramp`, `notion`, `perplexity`, and other companies using `jobs.ashbyhq.com`.

It returns one dataset row per job posting, including the title, team, location, department, employment type, workplace type, compensation summary when available, job URL, posting IDs, and scrape timestamp.

You can also enable full job descriptions when you need role requirements, benefits, or long-form hiring content for analysis.

### Who is it for?

- 🧲 **Recruiting analytics teams** tracking which startups and technology companies are hiring.
- 🧑‍💼 **Sales and lead-generation teams** finding companies with active hiring signals.
- 📰 **Job-board operators** refreshing Ashby-powered job listings.
- 📈 **Market researchers** comparing teams, locations, functions, and compensation trends.
- 🤖 **Automation builders** feeding live hiring data into CRMs, dashboards, or alerts.

### Why use this Actor?

Ashby is widely used by venture-backed and high-growth companies. Manually checking each board is slow, inconsistent, and hard to automate.

This Actor gives you repeatable structured output with filters, limits, and optional descriptions.

### Common use cases

- Monitor live hiring at a list of target companies.
- Build a startup jobs dataset for a niche job board.
- Track which teams are expanding by company.
- Find companies hiring for sales, engineering, security, finance, or operations roles.
- Export job openings into Google Sheets, Airtable, Snowflake, or a CRM.
- Compare location patterns such as remote, New York, London, or San Francisco.

### What data can you extract?

| Field | Description |
| --- | --- |
| `companySlug` | Ashby hosted board slug |
| `companyName` | Company name shown on the board |
| `jobId` | Ashby job identifier |
| `postingId` | Public posting identifier used in the job URL |
| `title` | Job title |
| `team` | Team name |
| `teamId` | Team identifier |
| `locationName` | Primary location |
| `secondaryLocations` | Additional locations |
| `employmentType` | Full-time, part-time, contract, or other value when available |
| `workplaceType` | Remote, hybrid, onsite, or similar value when available |
| `department` | Department name |
| `departmentId` | Department identifier |
| `publishedDate` | Posting publish date |
| `updatedAt` | Last update timestamp |
| `compensationTierSummary` | Compensation summary when displayed by the company |
| `jobUrl` | Public Ashby job URL |
| `descriptionHtml` | Full description HTML when enabled |
| `descriptionText` | Plain-text description when enabled |
| `scrapedAt` | Timestamp for the scrape |

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

This Actor uses pay-per-event pricing.

You pay a small start fee for each run and a per-result fee for each job posting saved to the dataset.

Current pricing:

- Start fee: **$0.005 per run**.
- FREE tier: **$0.000029762 per job posting**.
- BRONZE tier: **$0.00002588 per job posting**.
- SILVER tier: **$0.000020186 per job posting**.
- GOLD tier: **$0.000015528 per job posting**.
- PLATINUM tier: **$0.000010352 per job posting**.
- DIAMOND tier: **$0.0000072464 per job posting**.

For the cheapest first run, use the default prefill or set `maxItems` to a low number such as `25` or `50`. At the BRONZE tier, 1,000 job postings cost about **$0.02588** plus the run start fee.

### Input options

| Input | Type | Required | Description |
| --- | --- | --- | --- |
| `companySlugsOrUrls` | array of strings | yes | Ashby company slugs or full `jobs.ashbyhq.com` board URLs |
| `maxItems` | integer | no | Maximum job postings to save across all boards |
| `teamFilter` | string | no | Case-insensitive filter for team names |
| `locationFilter` | string | no | Case-insensitive filter for primary or secondary locations |
| `includeDescriptions` | boolean | no | Adds full job description HTML and text |

### Example input

```json
{
  "companySlugsOrUrls": ["openai", "ramp", "https://jobs.ashbyhq.com/notion"],
  "maxItems": 100,
  "teamFilter": "Engineering",
  "locationFilter": "San Francisco",
  "includeDescriptions": false
}
````

### Input tips

- Use plain slugs like `openai` when possible.
- Full board URLs such as `https://jobs.ashbyhq.com/ramp` also work.
- `maxItems` applies across all submitted companies.
- Leave filters blank to collect every public posting.
- Enable descriptions only when you need detailed role text.
- Description mode is slower because it adds more page visits.

### Output example

```json
{
  "companySlug": "openai",
  "companyName": "OpenAI",
  "jobId": "d4446040-9dd7-4116-8534-91a804a81b3c",
  "postingId": "2c3ab9f8-e7d0-48b7-9817-afe1b6ddece2",
  "title": "3D Printing Lab Technician, Robotics",
  "team": "Robotics",
  "teamId": "c16efb3c-493d-401c-a76f-a493cfccbeb8",
  "locationName": "San Francisco",
  "secondaryLocations": [],
  "employmentType": "FullTime",
  "workplaceType": "Hybrid",
  "department": "Research",
  "publishedDate": "2026-05-19",
  "compensationTierSummary": "$266K – $399K • Offers Equity",
  "jobUrl": "https://jobs.ashbyhq.com/openai/2c3ab9f8-e7d0-48b7-9817-afe1b6ddece2",
  "scrapedAt": "2026-06-17T00:00:00.000Z"
}
```

### How to scrape Ashby job boards

1. Open the Actor on Apify.
2. Add Ashby company slugs or board URLs.
3. Set a low `maxItems` for the first test.
4. Add optional team or location filters.
5. Choose whether to include full descriptions.
6. Click **Start**.
7. Download results from the dataset tab as JSON, CSV, Excel, XML, or RSS.

### Filtering examples

#### Engineering roles

```json
{
  "companySlugsOrUrls": ["openai", "notion"],
  "teamFilter": "Engineering",
  "maxItems": 100
}
```

#### New York roles

```json
{
  "companySlugsOrUrls": ["ramp"],
  "locationFilter": "New York",
  "maxItems": 50
}
```

#### Description analysis

```json
{
  "companySlugsOrUrls": ["perplexity"],
  "includeDescriptions": true,
  "maxItems": 25
}
```

### Best practices

- Start with 1-3 companies to confirm the output shape.
- Use `maxItems` to keep exploratory runs small.
- Turn on descriptions only when you need long-form content.
- Use filters to reduce noise for alerts and dashboards.
- Schedule runs daily or weekly for hiring-monitoring workflows.
- Store historical exports if you need change detection over time.

### Integrations

You can connect this Actor to:

- Google Sheets for recruiting intelligence dashboards.
- Slack for alerts when target companies add roles.
- Airtable for job-board editorial workflows.
- HubSpot or Salesforce for hiring-trigger lead enrichment.
- Snowflake, BigQuery, or S3 for long-term market datasets.
- Zapier or Make for no-code automations.

### API usage

#### Node.js

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

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

const run = await client.actor('fetch_cat/ashby-jobs-scraper').call({
  companySlugsOrUrls: ['openai', 'ramp'],
  maxItems: 100,
});

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

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/ashby-jobs-scraper').call(run_input={
    'companySlugsOrUrls': ['openai', 'ramp'],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~ashby-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"companySlugsOrUrls":["openai","ramp"],"maxItems":100}'
```

### MCP usage

Use Apify MCP to call this Actor from Claude Code, Claude Desktop, or other MCP clients.

MCP endpoint:

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

Claude Code setup:

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

Claude Desktop MCP JSON config:

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

Example prompts for MCP usage:

- "Use the Apify Ashby Jobs Scraper MCP tool to scrape OpenAI and Ramp, then summarize engineering hiring by location."
- "Call the Ashby Jobs Scraper for Notion and return jobs whose titles or teams mention design or product."
- "Run the Ashby Jobs Scraper MCP tool for Perplexity with maxItems 50 and return a CSV-ready table."

### Scheduling

For hiring intelligence, schedule the Actor to run every day or every week.

Daily schedules work well for sales triggers and job-board freshness. Weekly schedules are usually enough for market reports and competitive research.

### Data freshness

The Actor returns currently visible public job postings at run time.

If a company removes a posting, future runs will no longer include it. Keep historical datasets if you need opening and closing dates.

### Limits and caveats

- Only public Ashby hosted boards are supported.
- The Actor does not access private applicant data.
- Some companies may have zero public roles.
- Some fields depend on what the company chooses to display.
- Compensation summaries appear only when visible on the public board.
- Very large company lists should use a practical `maxItems` limit.

### Troubleshooting

#### Why did a company return no jobs?

The company may not use a public Ashby hosted board, may have no public openings, or may use a different slug. Open `https://jobs.ashbyhq.com/<slug>` in a browser to confirm the board exists.

#### Why are descriptions missing?

Descriptions are included only when `includeDescriptions` is set to `true`. Leave it off for faster runs when listing-level fields are enough.

#### Why did I get fewer jobs than expected?

`maxItems` is a global cap across all companies. Filters can also reduce results. Increase `maxItems` or remove filters to collect more postings.

### Legality and privacy

This Actor collects publicly available job posting information from public company career pages.

You are responsible for using the data in accordance with applicable laws, website terms, and privacy requirements. Do not use scraped data for spam, discrimination, or unlawful employment practices.

### Related scrapers

Other actors by fetch\_cat that may help with recruiting and market research:

- https://apify.com/fetch\_cat/y-combinator-companies-scraper
- https://apify.com/fetch\_cat/reddit-scraper
- https://apify.com/fetch\_cat/craigslist-classifieds-scraper

### FAQ

#### Can I scrape multiple companies in one run?

Yes. Add multiple slugs or URLs to `companySlugsOrUrls`.

#### Can I filter by remote jobs?

Yes. Use `locationFilter` with values such as `Remote`, or inspect `workplaceType` in the output.

#### Can I get salary data?

The Actor returns `compensationTierSummary` when the public posting displays compensation.

#### Can I use this for alerts?

Yes. Schedule regular runs and compare the latest dataset with previous results in your own workflow.

#### Does this require an Ashby account?

No. It is designed for public Ashby job boards.

#### Does it scrape applicants or candidates?

No. It only extracts public job posting information.

#### What if a company uses Greenhouse, Lever, Workday, or another ATS?

This Actor is focused on Ashby hosted job boards. Use a matching ATS scraper for other platforms.

### Changelog

- Initial version: collect Ashby public job postings with optional description extraction.

# Actor input Schema

## `companySlugsOrUrls` (type: `array`):

Ashby hosted board slugs or URLs, such as openai or https://jobs.ashbyhq.com/openai.

## `maxItems` (type: `integer`):

Maximum number of job postings to save across all boards.

## `teamFilter` (type: `string`):

Optional case-insensitive substring filter for Ashby team names, for example Engineering or Sales.

## `locationFilter` (type: `string`):

Optional case-insensitive substring filter for primary or secondary locations, for example Remote, London, or San Francisco.

## `includeDescriptions` (type: `boolean`):

Fetch each job detail page and add descriptionHtml and descriptionText. This is slower but useful for content analysis.

## Actor input object example

```json
{
  "companySlugsOrUrls": [
    "openai",
    "ramp"
  ],
  "maxItems": 20,
  "includeDescriptions": 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 = {
    "companySlugsOrUrls": [
        "openai",
        "ramp"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/ashby-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 = { "companySlugsOrUrls": [
        "openai",
        "ramp",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/ashby-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 '{
  "companySlugsOrUrls": [
    "openai",
    "ramp"
  ]
}' |
apify call fetch_cat/ashby-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ashby Jobs Scraper",
        "description": "Extract live jobs from public Ashby career boards with team, location, compensation, IDs, URLs, and optional full descriptions.",
        "version": "0.1",
        "x-build-id": "UO6GiyF6OzDXYYnav"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~ashby-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-ashby-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~ashby-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-ashby-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~ashby-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-ashby-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",
                "required": [
                    "companySlugsOrUrls"
                ],
                "properties": {
                    "companySlugsOrUrls": {
                        "title": "Company slugs or Ashby board URLs",
                        "type": "array",
                        "description": "Ashby hosted board slugs or URLs, such as openai or https://jobs.ashbyhq.com/openai.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job postings to save across all boards.",
                        "default": 20
                    },
                    "teamFilter": {
                        "title": "Team filter",
                        "type": "string",
                        "description": "Optional case-insensitive substring filter for Ashby team names, for example Engineering or Sales."
                    },
                    "locationFilter": {
                        "title": "Location filter",
                        "type": "string",
                        "description": "Optional case-insensitive substring filter for primary or secondary locations, for example Remote, London, or San Francisco."
                    },
                    "includeDescriptions": {
                        "title": "Include full descriptions",
                        "type": "boolean",
                        "description": "Fetch each job detail page and add descriptionHtml and descriptionText. This is slower but useful for content analysis.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
