# Career Site Job Listing Scraper (`khadinakbar/career-site-job-scraper`) Actor

Scrape live job listings straight from company career pages via their ATS public JSON APIs. Auto-detects Greenhouse, Lever, Ashby, SmartRecruiters, Workable, Recruitee, with a JSON-LD fallback. MCP/API-ready.

- **URL**: https://apify.com/khadinakbar/career-site-job-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Jobs, MCP servers, Lead generation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 job scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Career Site Job Listing Scraper

Scrape live job listings **straight from a company's own career page** — not from an aggregator. Paste any career URL and the actor auto-detects the Applicant Tracking System (ATS) behind it, calls that platform's public JSON API, and returns every open role with title, location, department, employment type, salary (when published), full description, apply URL, and posted date.

HTTP-only, no login, no cookies, no browser — so it is fast, cheap, and highly reliable.

### What it does

Most company career pages are powered by a handful of ATS platforms. This actor recognises them from the URL (or by sniffing the page HTML) and reads their official public job feed:

- **Greenhouse** — `boards.greenhouse.io/<company>`, `job-boards.greenhouse.io/<company>`, or a custom domain embedding Greenhouse
- **Lever** — `jobs.lever.co/<company>`
- **Ashby** — `jobs.ashbyhq.com/<company>`
- **Workday** — `<tenant>.<dc>.myworkdayjobs.com/<site>` (e.g. `acme.wd5.myworkdayjobs.com/en-US/careers`)
- **SmartRecruiters** — `jobs.smartrecruiters.com/<Company>`
- **Recruitee** — `<company>.recruitee.com`
- **Workable** — `apply.workable.com/<company>`
- **Any other site** — falls back to parsing `schema.org/JobPosting` structured data (the same data Google for Jobs reads)

You give it URLs; it gives you a clean, flat, one-row-per-job dataset.

### When to use it

- Recruiters and sourcers building a live pipeline of openings at target companies
- Sales / BD teams that sell to companies who are hiring (hiring = budget = intent signal)
- Job-board and aggregator builders who want first-party listings instead of stale re-posts
- Labor-market and competitive-intelligence research
- AI agents that need "what jobs is company X hiring for right now?" as a single tool call

### When NOT to use it

- To search a job **aggregator** (Indeed, LinkedIn, Google Jobs) — use a dedicated aggregator scraper instead. This actor reads one company's own career page.
- To scrape candidate or recruiter **profiles** — this returns job postings only.

### Output

One record per open job listing:

| Field | Description |
|---|---|
| `jobTitle` | Job title |
| `company` | Employer name (when the ATS exposes it) |
| `department` | Department / team category |
| `team` | Sub-team, where available |
| `location` | Primary location string |
| `additionalLocations` | Other eligible locations (array) |
| `isRemote` | `true` / `false` / `null` when unknown |
| `employmentType` | Full-time, Part-time, Contract, etc. |
| `salaryText` | Published salary/compensation, when present |
| `description` | Job description (plain text by default; see `descriptionFormat`) |
| `descriptionHtml` | Raw HTML description (only when `descriptionFormat` is `html` or `both`) |
| `applyUrl` | Direct application URL |
| `jobUrl` | Canonical job posting URL |
| `jobId` | ATS job identifier |
| `postedAt` | First published date (ISO 8601) |
| `updatedAt` | Last updated date (ISO 8601), when available |
| `ats` | Detected platform (`greenhouse`, `lever`, `ashby`, …) |
| `atsToken` | The company slug/token used against the ATS |
| `sourceUrl` | The career URL you submitted |
| `scrapedAt` | Run timestamp (ISO 8601) |

#### Example record

```json
{
  "jobTitle": "Senior Backend Engineer",
  "company": "Acme Corp",
  "department": "Engineering",
  "location": "Berlin, DE",
  "additionalLocations": ["Remote (EU)"],
  "isRemote": true,
  "employmentType": "FullTime",
  "salaryText": "€70K – €90K",
  "description": "Build scalable APIs. Own services end to end…",
  "applyUrl": "https://jobs.ashbyhq.com/acme/123/application",
  "jobUrl": "https://jobs.ashbyhq.com/acme/123",
  "jobId": "123",
  "postedAt": "2026-05-01T00:00:00.000Z",
  "ats": "ashby",
  "atsToken": "acme",
  "sourceUrl": "https://jobs.ashbyhq.com/acme",
  "scrapedAt": "2026-07-01T10:40:42.543Z"
}
````

### Pricing (pay per event)

| Event | Price | When |
|---|---|---|
| Actor start | $0.00005 | Once per run |
| Job scraped | **$0.004** | Per job returned |
| Description enriched | $0.002 | Only for SmartRecruiters / Workable / Workday jobs (and Ashby boards without the inline posting API) that need an extra per-job request for the full description |

Greenhouse, Lever, and Recruitee include full descriptions in the listing call — those are **never** charged the enrichment fee. Pay-per-usage (compute + proxy) billing is also available for very large jobs.

A typical run of 200 jobs from a single Greenhouse board costs about **$0.80**.

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `startUrls` | string\[] | — (required) | One career-page URL per line |
| `maxResultsPerSite` | integer | 200 | Cap per URL |
| `enrichDescriptions` | boolean | true | Extra fetch for SmartRecruiters / Workable / Workday / Ashby-GraphQL descriptions |
| `descriptionFormat` | enum | `text` | `text` · `html` · `both` · `none` |
| `proxyConfiguration` | proxy | direct | ATS APIs are open; enable Apify Proxy only if needed |

```json
{
  "startUrls": [
    "https://boards.greenhouse.io/stripe",
    "https://jobs.ashbyhq.com/ramp",
    "https://jobs.lever.co/highspot"
  ],
  "maxResultsPerSite": 200,
  "descriptionFormat": "text"
}
```

### How ATS detection works

1. If the URL matches a known ATS host (Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Recruitee, Workable), the company token is parsed straight from the URL — zero extra requests.
2. Otherwise the actor fetches the page once and sniffs embedded ATS markers (e.g. a Greenhouse embed `for=` token, a Lever board link).
3. If no known ATS is found, it parses `schema.org/JobPosting` structured data from the page as a best-effort fallback.

Pages on unsupported/custom platforms with no structured data are reported as `unsupported` in the run summary — never a silent failure.

### For AI agents (MCP)

Exposed as `apify--career-site-job-scraper` on the Apify MCP server. Narrow input (career URLs), flat structured output, sub-second-to-seconds runtime, predictable per-event cost. Ideal for "list current openings at company X" tool calls. A per-run summary is written to the key-value store `OUTPUT` key with per-site outcomes and billing counts.

### Use via API (JavaScript)

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('khadinakbar/career-site-job-scraper').call({
  startUrls: ['https://boards.greenhouse.io/stripe'],
  maxResultsPerSite: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### FAQ

**Which companies are supported?** Any company whose career page runs on Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Recruitee, or Workable — that is the large majority of tech, startup, enterprise, and mid-market employers — plus any page exposing JobPosting structured data.

**Do I need proxies?** No. The ATS APIs are public and open. A direct connection is the default. Enable Apify Proxy only if you hit rate limits.

**Why did a page return zero jobs?** Either the company genuinely has no open roles, or its career page runs on an unsupported platform (e.g. BambooHR, iCIMS, Jobvite) with no structured data. The run summary distinguishes the two.

**Can I get full descriptions?** Yes. They are included inline for most platforms. For SmartRecruiters and Workable, keep `enrichDescriptions` on.

### Legal

This actor collects only publicly available job-posting data exposed by companies' own career pages and their ATS public APIs. It performs no login and bypasses no access controls. You are responsible for using the data in compliance with the source sites' terms and applicable law (including data-protection regulations). Not affiliated with or endorsed by Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Recruitee, or Workable.

# Actor input Schema

## `startUrls` (type: `array`):

One or more company career-page URLs to scrape. Paste any career/jobs page and the actor auto-detects the ATS behind it — Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Recruitee, or Workable (e.g. 'https://boards.greenhouse.io/stripe', 'https://jobs.ashbyhq.com/posthog', 'https://acme.wd5.myworkdayjobs.com/en-US/careers', or a custom domain like 'https://careers.stripe.com' — it sniffs the embedded ATS). Accepts plain URL strings, one per line. NOT a job-board aggregator query (Indeed/LinkedIn) — this reads a single company's own career page.

## `maxResultsPerSite` (type: `integer`):

Upper bound on how many job listings to return from each career page. Accepts a whole number (e.g. 200). Defaults to 200; set to a high value like 5000 to pull an entire board. Applied per URL, so total cost scales with URL count times this cap.

## `enrichDescriptions` (type: `boolean`):

Fetch the complete job description for ATS platforms that do NOT return it in the listing call (SmartRecruiters, Workable, Workday, and Ashby boards without the inline posting API) via one extra request per job. Accepts true/false. Defaults to true. When false, those platforms return listing fields only; platforms that include descriptions inline (Greenhouse, Lever, Recruitee) are unaffected and always free.

## `descriptionFormat` (type: `string`):

How to render the job description field. 'text' returns clean plain text (best for AI agents and resume-matching), 'html' returns the raw HTML, 'both' returns plain text plus a separate descriptionHtml field, and 'none' omits descriptions for the smallest, fastest output. Defaults to 'text'.

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

Optional proxy routing. ATS public JSON APIs are open and usually need no proxy, so this defaults to a direct connection. Enable Apify Proxy only if you hit rate limits or geo-restricted boards; set a countryCode for geo-specific listings.

## Actor input object example

```json
{
  "startUrls": [
    "https://jobs.lever.co/highspot"
  ],
  "maxResultsPerSite": 200,
  "enrichDescriptions": true,
  "descriptionFormat": "text",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One record per open job listing found across the submitted career pages.

## `summary` (type: `string`):

Per-site outcomes, detected ATS platforms, and billing counts for this run.

# 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 = {
    "startUrls": [
        "https://boards.greenhouse.io/stripe",
        "https://jobs.ashbyhq.com/posthog"
    ],
    "maxResultsPerSite": 200,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/career-site-job-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 = {
    "startUrls": [
        "https://boards.greenhouse.io/stripe",
        "https://jobs.ashbyhq.com/posthog",
    ],
    "maxResultsPerSite": 200,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/career-site-job-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 '{
  "startUrls": [
    "https://boards.greenhouse.io/stripe",
    "https://jobs.ashbyhq.com/posthog"
  ],
  "maxResultsPerSite": 200,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call khadinakbar/career-site-job-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Career Site Job Listing Scraper",
        "description": "Scrape live job listings straight from company career pages via their ATS public JSON APIs. Auto-detects Greenhouse, Lever, Ashby, SmartRecruiters, Workable, Recruitee, with a JSON-LD fallback. MCP/API-ready.",
        "version": "1.1",
        "x-build-id": "bvp7DrXhLEvqDG2IF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~career-site-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-career-site-job-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/khadinakbar~career-site-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-career-site-job-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/khadinakbar~career-site-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-career-site-job-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Career page URLs",
                        "type": "array",
                        "description": "One or more company career-page URLs to scrape. Paste any career/jobs page and the actor auto-detects the ATS behind it — Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Recruitee, or Workable (e.g. 'https://boards.greenhouse.io/stripe', 'https://jobs.ashbyhq.com/posthog', 'https://acme.wd5.myworkdayjobs.com/en-US/careers', or a custom domain like 'https://careers.stripe.com' — it sniffs the embedded ATS). Accepts plain URL strings, one per line. NOT a job-board aggregator query (Indeed/LinkedIn) — this reads a single company's own career page.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerSite": {
                        "title": "Max jobs per career page",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Upper bound on how many job listings to return from each career page. Accepts a whole number (e.g. 200). Defaults to 200; set to a high value like 5000 to pull an entire board. Applied per URL, so total cost scales with URL count times this cap.",
                        "default": 200
                    },
                    "enrichDescriptions": {
                        "title": "Enrich full descriptions",
                        "type": "boolean",
                        "description": "Fetch the complete job description for ATS platforms that do NOT return it in the listing call (SmartRecruiters, Workable, Workday, and Ashby boards without the inline posting API) via one extra request per job. Accepts true/false. Defaults to true. When false, those platforms return listing fields only; platforms that include descriptions inline (Greenhouse, Lever, Recruitee) are unaffected and always free.",
                        "default": true
                    },
                    "descriptionFormat": {
                        "title": "Description format",
                        "enum": [
                            "text",
                            "html",
                            "both",
                            "none"
                        ],
                        "type": "string",
                        "description": "How to render the job description field. 'text' returns clean plain text (best for AI agents and resume-matching), 'html' returns the raw HTML, 'both' returns plain text plus a separate descriptionHtml field, and 'none' omits descriptions for the smallest, fastest output. Defaults to 'text'.",
                        "default": "text"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy routing. ATS public JSON APIs are open and usually need no proxy, so this defaults to a direct connection. Enable Apify Proxy only if you hit rate limits or geo-restricted boards; set a countryCode for geo-specific listings.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
