# Job Board Keyword Signal Scanner (`automation-lab/job-board-keyword-signal-scanner`) Actor

🔎 Scan public ATS job boards for hiring-signal keywords. Find technology, role, compliance, and GTM triggers from Greenhouse, Lever, and Ashby.

- **URL**: https://apify.com/automation-lab/job-board-keyword-signal-scanner.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation, Jobs
- **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.
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

## Job Board Keyword Signal Scanner

Turn public job boards into hiring-signal intelligence. This actor scans Greenhouse, Lever, Ashby, and simple careers pages for the exact keywords that matter to your sales, recruiting, RevOps, investment, or market research workflow.

### What does Job Board Keyword Signal Scanner do?

Job Board Keyword Signal Scanner accepts public ATS or careers-page URLs and a list of keywords. It returns matching job posts with company name, ATS source, job title, location, department, posting URL, dates, matched keywords, and a context snippet.

Use it when you want to know which companies are hiring for specific tools, teams, compliance programs, seniority levels, or go-to-market motions.

### Who is it for?

- 🧭 **B2B sales teams** looking for buying triggers such as Salesforce, HubSpot, SOC2, Snowflake, AI, RevOps, or security hiring.
- 🧑‍💼 **Recruiters** monitoring companies hiring for specific roles or technologies.
- 📈 **RevOps teams** enriching account lists before routing them to SDRs.
- 💼 **Investors and analysts** tracking company priorities through hiring language.
- 🧪 **Growth teams** testing niches before building a larger account-intelligence workflow.

### Why use this actor?

Hiring pages are public, current, and rich with intent. A company hiring Salesforce administrators, AI platform engineers, RevOps managers, or security compliance roles is often signaling an active internal project. This actor makes those signals exportable and API-ready.

### Supported sources

- Greenhouse public job board API and Greenhouse board URLs.
- Lever public posting API and `jobs.lever.co` board URLs.
- Ashby posting API URLs.
- Generic careers pages as a lightweight fallback.

### Data you can extract

| Field | Description |
| --- | --- |
| company | Company or job board owner |
| sourceAts | Greenhouse, Lever, Ashby, or generic |
| jobTitle | Public job title |
| location | Location exposed by the ATS |
| department | Team or department when available |
| postingUrl | Public URL for the matched job |
| jobId | ATS job ID when available |
| firstPublishedAt | First publish timestamp when available |
| updatedAt | Last update timestamp when available |
| matchedKeywords | Keywords found in title, metadata, or description |
| matchCount | Number of matched keywords |
| snippet | Context around the first match |
| descriptionText | Optional full text when enabled |
| sourceUrl | Input URL scanned |
| scrapedAt | Extraction timestamp |

### How much does it cost to scan job boards for hiring signals?

This actor uses pay-per-event pricing. There is a small start event for each run and a per-item event for each matched job saved to the dataset. Keep your first run small by using the prefilled example and `maxResults` around 25.

### How to use it

1. Open the actor on Apify.
2. Add one or more public job board URLs.
3. Add keywords such as `salesforce`, `revops`, `soc2`, `ai`, `snowflake`, or `security`.
4. Choose `any` keyword matching for broad discovery or `all` for strict matching.
5. Run the actor and export the dataset as JSON, CSV, Excel, or via API.

### Input example

```json
{
  "sources": [
    {
      "url": "https://boards-api.greenhouse.io/v1/boards/airbnb/jobs?content=true",
      "companyName": "Airbnb",
      "source": "greenhouse"
    },
    {
      "url": "https://api.ashbyhq.com/posting-api/job-board/ashby?includeCompensation=true",
      "companyName": "Ashby",
      "source": "ashby"
    }
  ],
  "keywords": ["salesforce", "revops", "soc2", "ai"],
  "maxResults": 25,
  "matchMode": "any",
  "includeFullDescription": false
}
````

### Output example

```json
{
  "company": "Airbnb",
  "sourceAts": "greenhouse",
  "jobTitle": "Senior Salesforce Engineer",
  "location": "United States",
  "department": "Business Technology",
  "postingUrl": "https://boards.greenhouse.io/...",
  "jobId": "123456",
  "firstPublishedAt": "2026-06-01T00:00:00Z",
  "updatedAt": "2026-06-18T00:00:00Z",
  "matchedKeywords": ["salesforce"],
  "matchCount": 1,
  "snippet": "...own Salesforce workflows and integrations...",
  "sourceUrl": "https://boards-api.greenhouse.io/v1/boards/airbnb/jobs?content=true",
  "scrapedAt": "2026-06-20T20:00:00.000Z"
}
```

### Keyword tips

- Use product names: Salesforce, HubSpot, Snowflake, Databricks.
- Use departments: RevOps, GTM, Partnerships, Security, Compliance.
- Use initiatives: SOC2, ISO 27001, AI, ML, data platform, cloud migration.
- Use role language: founding AE, solutions architect, customer success, platform engineer.

### Match modes

`any` saves a job when at least one keyword appears. This is best for discovery and broader lead lists.

`all` saves a job only when every keyword appears. This is best when you need high-confidence signals such as `salesforce` plus `revops`.

### Integrations

- Send matched companies to a CRM as account triggers.
- Join output with a domain resolver or LinkedIn company URL actor.
- Enrich matched companies with contact details.
- Send matching job posts to Slack for daily GTM alerts.
- Load the dataset into Clay, Airtable, Google Sheets, or a warehouse.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/job-board-keyword-signal-scanner').call({
  sources: [{ url: 'https://boards-api.greenhouse.io/v1/boards/airbnb/jobs?content=true', companyName: 'Airbnb' }],
  keywords: ['salesforce', 'revops'],
  maxResults: 25
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/job-board-keyword-signal-scanner').call(run_input={
    'sources': [{'url': 'https://api.ashbyhq.com/posting-api/job-board/ashby?includeCompensation=true', 'companyName': 'Ashby'}],
    'keywords': ['ai', 'security'],
    'maxResults': 25,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~job-board-keyword-signal-scanner/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"sources":[{"url":"https://boards-api.greenhouse.io/v1/boards/airbnb/jobs?content=true","companyName":"Airbnb"}],"keywords":["salesforce","revops"],"maxResults":25}'
```

### MCP usage

Use the Apify MCP server with Claude Code or Claude Desktop to run this actor as a tool:

`https://mcp.apify.com/?tools=automation-lab/job-board-keyword-signal-scanner`

Claude Code setup:

```bash
claude mcp add apify-job-board-keyword-signal-scanner \
  https://mcp.apify.com/?tools=automation-lab/job-board-keyword-signal-scanner
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-job-board-keyword-signal-scanner": {
      "url": "https://mcp.apify.com/?tools=automation-lab/job-board-keyword-signal-scanner"
    }
  }
}
```

Example prompts:

- "Scan these Greenhouse URLs for Salesforce and RevOps hiring signals."
- "Find companies hiring for SOC2 or security compliance roles."
- "Turn this list of Lever boards into GTM trigger signals."

### Best practices

- Start with 5-20 companies and a small keyword list.
- Use companyName when the URL does not reveal the company clearly.
- Keep `includeFullDescription` off unless you need the text for downstream LLM enrichment.
- Use `maxResults` to cap exploratory runs.

### Troubleshooting

If a source returns no matches, check that the job board is public and that your keywords appear in visible job text. Use broader keywords first, then narrow down.

If a generic careers page gives only one result, that is expected. Generic mode scans a page as a fallback signal source, while Greenhouse, Lever, and Ashby return individual job posts.

### Limitations

The actor reads public job-board data only. It does not log into private ATS systems, submit applications, bypass access controls, or scrape candidate data. Some companies customize their careers pages in ways that require a future adapter.

### Legality

This actor is designed for public business and hiring information. Always respect applicable laws, platform terms, privacy obligations, and your own compliance rules. Do not use the output for discriminatory employment decisions.

### Related scrapers and workflows

- https://apify.com/automation-lab/domain-to-linkedin-url-resolver
- https://apify.com/automation-lab/contact-details-scraper
- https://apify.com/automation-lab/b2b-url-finder

### Changelog

- 0.1 — Initial version with Greenhouse, Lever, Ashby, and generic careers-page scanning.

### FAQ

#### Can I scan any company careers page?

Yes, but structured results work best with Greenhouse, Lever, and Ashby. Generic pages are treated as page-level signals.

#### Does this actor need proxies?

No proxy is required for the default public ATS API workflow.

#### Can I monitor the same companies every week?

Yes. Create an Apify task with your sources and keywords, then schedule it daily or weekly.

#### Can I export to CSV?

Yes. Use Apify dataset export to download JSON, CSV, Excel, XML, RSS, or HTML.

#### Can I include full descriptions?

Yes. Enable `includeFullDescription` if your workflow needs complete text for LLM processing or deeper enrichment.

# Actor input Schema

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

Public Greenhouse, Lever, Ashby, or careers-page URLs to scan. Add companyName when the URL does not make the company obvious.

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

Technology, role, department, compliance, or intent keywords. Matching is case-insensitive.

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

Stop after this many matching job posts are saved.

## `matchMode` (type: `string`):

Use any to find jobs matching at least one keyword, or all for stricter signals.

## `includeFullDescription` (type: `boolean`):

When enabled, output includes a truncated full description text. Leave off for lighter datasets.

## Actor input object example

```json
{
  "sources": [
    {
      "url": "https://boards-api.greenhouse.io/v1/boards/airbnb/jobs?content=true",
      "companyName": "Airbnb",
      "source": "greenhouse"
    },
    {
      "url": "https://api.ashbyhq.com/posting-api/job-board/ashby?includeCompensation=true",
      "companyName": "Ashby",
      "source": "ashby"
    }
  ],
  "keywords": [
    "salesforce",
    "revops",
    "soc2",
    "ai"
  ],
  "maxResults": 20,
  "matchMode": "any",
  "includeFullDescription": 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 = {
    "sources": [
        {
            "url": "https://boards-api.greenhouse.io/v1/boards/airbnb/jobs?content=true",
            "companyName": "Airbnb",
            "source": "greenhouse"
        },
        {
            "url": "https://api.ashbyhq.com/posting-api/job-board/ashby?includeCompensation=true",
            "companyName": "Ashby",
            "source": "ashby"
        }
    ],
    "keywords": [
        "salesforce",
        "revops",
        "soc2",
        "ai"
    ],
    "maxResults": 20,
    "matchMode": "any",
    "includeFullDescription": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/job-board-keyword-signal-scanner").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "sources": [
        {
            "url": "https://boards-api.greenhouse.io/v1/boards/airbnb/jobs?content=true",
            "companyName": "Airbnb",
            "source": "greenhouse",
        },
        {
            "url": "https://api.ashbyhq.com/posting-api/job-board/ashby?includeCompensation=true",
            "companyName": "Ashby",
            "source": "ashby",
        },
    ],
    "keywords": [
        "salesforce",
        "revops",
        "soc2",
        "ai",
    ],
    "maxResults": 20,
    "matchMode": "any",
    "includeFullDescription": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/job-board-keyword-signal-scanner").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "sources": [
    {
      "url": "https://boards-api.greenhouse.io/v1/boards/airbnb/jobs?content=true",
      "companyName": "Airbnb",
      "source": "greenhouse"
    },
    {
      "url": "https://api.ashbyhq.com/posting-api/job-board/ashby?includeCompensation=true",
      "companyName": "Ashby",
      "source": "ashby"
    }
  ],
  "keywords": [
    "salesforce",
    "revops",
    "soc2",
    "ai"
  ],
  "maxResults": 20,
  "matchMode": "any",
  "includeFullDescription": false
}' |
apify call automation-lab/job-board-keyword-signal-scanner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/job-board-keyword-signal-scanner",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Job Board Keyword Signal Scanner",
        "description": "🔎 Scan public ATS job boards for hiring-signal keywords. Find technology, role, compliance, and GTM triggers from Greenhouse, Lever, and Ashby.",
        "version": "0.1",
        "x-build-id": "A2EiFsgt8zYsDkyDY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~job-board-keyword-signal-scanner/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-job-board-keyword-signal-scanner",
                "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/automation-lab~job-board-keyword-signal-scanner/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-job-board-keyword-signal-scanner",
                "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/automation-lab~job-board-keyword-signal-scanner/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-job-board-keyword-signal-scanner",
                "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": [
                    "sources",
                    "keywords"
                ],
                "properties": {
                    "sources": {
                        "title": "ATS or careers page URLs",
                        "type": "array",
                        "description": "Public Greenhouse, Lever, Ashby, or careers-page URLs to scan. Add companyName when the URL does not make the company obvious.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "Job board URL",
                                    "description": "Public Greenhouse, Lever, Ashby, or careers page URL."
                                },
                                "companyName": {
                                    "type": "string",
                                    "title": "Company name",
                                    "description": "Optional company name override for cleaner output."
                                },
                                "source": {
                                    "type": "string",
                                    "title": "ATS source",
                                    "description": "Set the ATS type or leave auto detection enabled.",
                                    "enum": [
                                        "auto",
                                        "greenhouse",
                                        "lever",
                                        "ashby",
                                        "generic"
                                    ],
                                    "default": "auto"
                                }
                            }
                        }
                    },
                    "keywords": {
                        "title": "Keywords to match",
                        "type": "array",
                        "description": "Technology, role, department, compliance, or intent keywords. Matching is case-insensitive.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum matched jobs",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many matching job posts are saved.",
                        "default": 100
                    },
                    "matchMode": {
                        "title": "Keyword match mode",
                        "enum": [
                            "any",
                            "all"
                        ],
                        "type": "string",
                        "description": "Use any to find jobs matching at least one keyword, or all for stricter signals.",
                        "default": "any"
                    },
                    "includeFullDescription": {
                        "title": "Include full job description",
                        "type": "boolean",
                        "description": "When enabled, output includes a truncated full description text. Leave off for lighter datasets.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
