# Workable Jobs Scraper | Company Career Listings (`parseforge/workable-jobs-scraper`) Actor

Extract job postings from any Workable-hosted careers page including title, location, department, employment type, full description, salary, and apply URL. Track open roles across thousands of companies for sourcing, market intelligence, and recruiting analytics workflows.

- **URL**: https://apify.com/parseforge/workable-jobs-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Jobs, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 💼 Workable Jobs Scraper

> 🚀 **Export any company's Workable job board to CSV, Excel, or JSON in seconds.** No API key, no login - just the company slug.

> 🕒 **Last updated:** 2026-05-22 · **📊 18 fields** per record · **All Workable-powered boards** · **Global coverage**

The Workable Jobs Scraper extracts job listings from any company that uses [Workable](https://workable.com) as their Applicant Tracking System. Thousands of companies - from startups to mid-size enterprises - post their open roles at `apply.workable.com/{company-slug}`. This actor hits the official Workable public API and returns full job details including descriptions, requirements, and benefits.

**Dataset provenance:** All data is scraped in real-time from the Workable public API (`apply.workable.com`). No caching, no stale data.

**Coverage:** Any company with a public Workable job board. Over 50,000 companies use Workable globally. Fields include job title, location, remote status, department, workplace type, employment type, full description, requirements, and benefits.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Recruiters and talent teams, job seekers, HR analysts, sales teams, data scientists, market researchers | Monitor competitors' hiring activity, track open roles at target companies, benchmark job descriptions and requirements, identify companies growing specific departments, build NLP training datasets, gauge hiring trends at Workable customers |

---

### 📋 What the Workable Jobs Scraper does

- Accepts a company slug (the Workable subdomain, e.g. `intercom`, `typeform`, `same-day-water-heaters`)
- Verifies the company exists on Workable and retrieves its full name
- Paginates through all published job listings
- Fetches full job details (description, requirements, benefits) for each listing
- Returns clean, HTML-stripped text for all rich-text fields
- Exports to CSV, Excel, JSON, or XML with one click

> 💡 **Why it matters:** Workable powers job boards for thousands of companies that don't have a public API. This actor gives you structured, machine-readable access to any of them - instantly.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `companySlug` | string | ✅ Yes | Workable subdomain (e.g. `intercom`, `typeform`). Found in `apply.workable.com/{slug}` |
| `maxItems` | integer | No | Max jobs to return. Free: limited to 10. Paid: up to 1,000,000 |

**Example - scrape 10 jobs from a company:**
```json
{
  "companySlug": "same-day-water-heaters",
  "maxItems": 10
}
````

**Example - get all open positions:**

```json
{
  "companySlug": "typeform",
  "maxItems": 1000000
}
```

> ⚠️ **Good to Know:** The company slug is the subdomain used by the company on Workable. To find it, visit the company's careers page - it will be at `apply.workable.com/{slug}`. For example, if the URL is `apply.workable.com/intercom`, the slug is `intercom`.

### 📊 Output

| Field | Type | Description |
|-------|------|-------------|
| 🆔 `id` | string | Unique job identifier |
| 📌 `title` | string | Job title |
| 📍 `location` | string | Combined city and country |
| 🏙 `city` | string | City where the job is based |
| 🌍 `country` | string | Country where the job is based |
| 🏠 `remote` | boolean | Whether the job is remote |
| 🏢 `department` | string | Department or team |
| 🏗 `workplaceType` | string | `on_site`, `remote`, or `hybrid` |
| 💼 `employmentType` | string | `full`, `part`, `contract`, `temporary` |
| 📝 `description` | string | Full job description (HTML stripped) |
| ✅ `requirements` | string | Job requirements (HTML stripped) |
| 🎁 `benefits` | string | Benefits offered (HTML stripped, may be null) |
| 🔑 `companySlug` | string | Workable subdomain used |
| 🏷 `companyName` | string | Full company name |
| 🔗 `url` | string | Direct link to job application page |
| 📅 `createdAt` | string | Date job was posted (ISO 8601) |
| 🕒 `scrapedAt` | string | Timestamp of scrape (ISO 8601) |
| ❌ `error` | string | Error message if scraping failed (null on success) |

**Sample records (real data from cloud run):**

```json
[
  {
    "id": "5780672",
    "title": "Full-Service Plumber- Subcontractor (Weekends Only)",
    "location": "Dallas, United States",
    "city": "Dallas",
    "country": "United States",
    "remote": false,
    "department": "Water Heater & Fixture Installation",
    "workplaceType": "on_site",
    "employmentType": "contract",
    "description": "EARN MORE AS A PLUMBING SUBCONTRACTOR! WE NEED WEEKEND WARRIORS! Join the Same Day Water Heaters team...",
    "requirements": "Tradesman or above plumbing license. Excellent customer service skills. Current driver license...",
    "benefits": "Year-round opportunity! Incentives for excellent customer service scores. Be your own boss...",
    "companySlug": "same-day-water-heaters",
    "companyName": "Same Day Water Heaters",
    "url": "https://apply.workable.com/same-day-water-heaters/j/9CE07C0D01/",
    "createdAt": "2026-04-30T00:00:00.000Z",
    "scrapedAt": "2026-05-22T00:38:28.492Z",
    "error": null
  },
  {
    "id": "5694456",
    "title": "Full-Service Plumber- Staff",
    "location": "Round Rock, United States",
    "city": "Round Rock",
    "country": "United States",
    "remote": false,
    "department": "Water Heater & Fixture Installation",
    "workplaceType": "on_site",
    "employmentType": "full",
    "description": "Join Our Growing Team as a Full Service Plumber! Are you ready to take your plumbing career to the next level?...",
    "requirements": "Valid Tradesman or higher plumbing license. Exemplary customer service skills. Current driver's license...",
    "benefits": "Competitive pay plus commission. Year-round opportunity! Benefits to start after 60 days...",
    "companySlug": "same-day-water-heaters",
    "companyName": "Same Day Water Heaters",
    "url": "https://apply.workable.com/same-day-water-heaters/j/CF57203954/",
    "createdAt": "2026-04-14T00:00:00.000Z",
    "scrapedAt": "2026-05-22T00:38:28.601Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

| Feature | Detail |
|---------|--------|
| 🌐 No login required | Uses the Workable public API - no credentials needed |
| 🏃 Fast | Completes a full company board scrape in seconds |
| 📝 Full text | Description, requirements, and benefits all included - HTML stripped |
| 🔄 Paginated | Handles companies with 100+ open roles automatically |
| 🛡 Stable | Official Workable API - not brittle HTML parsing |
| 📦 Multi-format | CSV, Excel, JSON, XML - download from the dataset view |
| 🆓 Free preview | 10 items free - no card required |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual copy-paste | Generic scraper |
|---------|-----------|-------------------|-----------------|
| Structured JSON output | ✅ | ❌ | ⚠️ Partial |
| HTML-stripped descriptions | ✅ | ❌ | ❌ |
| Full requirements + benefits | ✅ | ⚠️ Manual | ❌ |
| Pagination (100+ jobs) | ✅ | ❌ | ⚠️ |
| CSV/Excel export | ✅ | ❌ | ⚠️ |
| Company validation | ✅ | N/A | ❌ |
| No setup required | ✅ | ✅ | ❌ |

### 🚀 How to use

1. Find the Workable job board URL for your target company (e.g. `apply.workable.com/typeform`)
2. Copy the slug - the part after the last slash (`typeform`)
3. Open this Actor on Apify and paste the slug into the **Company Slug** field
4. Set **Max Items** if you want to limit the results (leave blank for all)
5. Click **Start** - results appear in the dataset within seconds
6. Download as CSV, Excel, JSON, or XML from the dataset view

### 💼 Business use cases

#### Competitive Intelligence

Monitor which roles competitors are hiring for. Track volume of open positions over time. Identify new departments being built - engineering, sales, finance. Set up a recurring run to get weekly hiring snapshots automatically.

#### Talent Acquisition

Build a pipeline of companies actively hiring in your target function. Identify roles that match candidate profiles. Track open headcount at target accounts for outbound recruiting. Integrate with your ATS via Apify API or webhooks.

#### Sales Prospecting

Identify companies scaling specific teams (engineering, sales, customer success). Companies actively hiring are often also buying new tools. Filter by department to find accounts in your ICP. Export to CSV and load directly into your CRM.

#### Market Research

Benchmark compensation language and benefit offerings across companies. Analyze how job requirements differ by company size and stage. Track hiring trends as a leading indicator of business growth. Build datasets of job titles, skills, and locations for workforce analytics.

### 🔌 Automating Workable Jobs Scraper

**Make (formerly Integromat):** Use the Apify module to trigger a run on a schedule. Send new job records to a Google Sheet, Slack channel, or CRM automatically.

**Zapier:** Connect via the Apify Zap. Trigger on dataset completion. Push records to Airtable, Notion, HubSpot, or any of 5,000+ apps.

**Slack alerts:** Combine with a Zapier or Make scenario to post new job listings directly to a Slack channel - ideal for recruiting or competitive intelligence teams.

**Webhook:** Configure an Apify webhook to POST results to your own endpoint on run completion.

### 🌟 Beyond business use cases

#### Research

Academics studying labor markets can use this to collect longitudinal job posting data at the company level. Track how hiring patterns correlate with funding rounds, product launches, or market conditions.

#### Creative projects

Build a job board aggregator. Create a personal job alert system. Train a machine learning model on job description text. Build a browser extension that surfaces similar roles.

#### Non-profit

Workforce development organizations can track local employer hiring activity. Career counselors can monitor which skills are in demand at specific companies.

#### Experimentation

Developers learning to work with Apify can use this actor as a starting point for understanding the platform. Combine with an AI actor to auto-generate cover letters for each job scraped.

### 🤖 Ask an AI assistant about this scraper

You can paste the JSON output from this scraper directly into Claude, ChatGPT, or any other AI assistant and ask it to analyze the jobs, compare requirements, or summarize the hiring activity at a company.

### ❓ Frequently Asked Questions

#### 🔍 How do I find the company slug?

Visit the company's Workable careers page. The URL will be `apply.workable.com/{slug}`. Copy everything after the last slash. Example: `apply.workable.com/intercom` - the slug is `intercom`.

#### 🌐 Does this require login or an API key?

No. The Workable public API is accessible without authentication. This actor works out of the box.

#### 📋 What if a company has 0 open jobs?

The actor will return an error record indicating no jobs were found. This can happen if the company has no current openings or if they have paused their job board.

#### 🏠 Can I filter by remote jobs only?

Not yet - the actor returns all published jobs. You can filter the output dataset by the `remote` or `workplaceType` field after scraping.

#### 🎁 Why are some `benefits` fields null?

Benefits are optional in Workable. Many companies do not fill out the benefits section of their job postings. This is expected behavior - the field will be null when the company hasn't provided benefits text.

#### 💰 How much does it cost to run?

The first 10 results are free for all users. For more results, you need a paid Apify plan. The actor runs extremely fast - a company with 50 jobs typically completes in under 30 seconds.

#### 🔄 Can I monitor a company's hiring over time?

Yes. Use the Apify Scheduler to run this actor on a recurring basis. Each run will capture the current state of the job board. Compare datasets between runs to track new openings and closed roles.

#### 📊 What export formats are supported?

CSV, Excel (XLSX), JSON, XML, RSS. All available from the dataset view on Apify Console.

#### 🏢 Can I scrape multiple companies at once?

Each run handles one company slug. To scrape multiple companies, run the actor multiple times (once per slug) or use the Apify API to trigger runs programmatically in a loop.

#### 🔗 Are the job URLs direct apply links?

Yes. Each record includes a `url` field pointing directly to the Workable application page for that job (`apply.workable.com/{slug}/j/{shortcode}/`).

#### 🔍 How many companies use Workable?

Workable reports over 50,000 customers globally. The `jobs.workable.com` aggregate board lists over 170,000 active job postings at any given time.

#### 🕒 How fresh is the data?

All data is scraped in real-time when you trigger a run. There is no caching - you always get the current state of the company's job board.

### 🔌 Integrate with any app

Connect this actor to your workflow via Make, Zapier, Slack, Notion, Airtable, HubSpot, Salesforce, Google Sheets, or any app with a webhook or API. Use the Apify REST API for programmatic access to run results.

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [LinkedIn Jobs Scraper](https://apify.com/parseforge) | Scrape job listings from LinkedIn |
| [Indeed Scraper](https://apify.com/parseforge) | Extract jobs from Indeed job board |
| [Glassdoor Scraper](https://apify.com/parseforge) | Scrape Glassdoor jobs and reviews |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more ready-to-run scrapers.

***

**Disclaimer:** This actor accesses publicly available data from Workable job boards. All scraped data is publicly accessible without login. Use responsibly and in compliance with Workable's Terms of Service. ParseForge is not affiliated with Workable.

[Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)

# Actor input Schema

## `companySlug` (type: `string`):

Workable subdomain for the company (e.g. 'intercom', 'loom', 'typeform'). Found in apply.workable.com/{slug}

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "companySlug": "intercom",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "companySlug": "intercom",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/workable-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 = {
    "companySlug": "intercom",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/workable-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 '{
  "companySlug": "intercom",
  "maxItems": 10
}' |
apify call parseforge/workable-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Workable Jobs Scraper | Company Career Listings",
        "description": "Extract job postings from any Workable-hosted careers page including title, location, department, employment type, full description, salary, and apply URL. Track open roles across thousands of companies for sourcing, market intelligence, and recruiting analytics workflows.",
        "version": "0.1",
        "x-build-id": "n0fFDNU9rJAEdYBPJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~workable-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-workable-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/parseforge~workable-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-workable-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/parseforge~workable-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-workable-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": [
                    "companySlug"
                ],
                "properties": {
                    "companySlug": {
                        "title": "Company Slug",
                        "type": "string",
                        "description": "Workable subdomain for the company (e.g. 'intercom', 'loom', 'typeform'). Found in apply.workable.com/{slug}"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
