# Hiring Signal Monitor (`phantom_coder/hiring-signal-monitor`) Actor

Monitor competitor job boards weekly to reverse-engineer their clients and hiring patterns. Track Google News daily for funding events and office expansions. Identify companies with hiring intent and expansion plans. Built for B2B sales teams, staffing agencies, and management consultancies.

- **URL**: https://apify.com/phantom\_coder/hiring-signal-monitor.md
- **Developed by:** [Phantom Coder](https://apify.com/phantom_coder) (community)
- **Categories:** Jobs, Lead generation, News
- **Stats:** 5 total users, 2 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## 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

## Hiring Signal Monitor

Find out which companies your competitors are working with - before anyone else does.

Recruitment agencies, consultancies, and B2B sales teams use this Actor to:

- **See which companies your competitors are actively working with** by analyzing their public job listings
- **Catch companies raising funding or expanding** before they post their first job

A job board scraper that goes further than raw data - it tells you *who* your competitors are working with. Two modes: weekly job board intelligence + daily news signals.

---

### Who is it for

- **IT recruitment agencies** - identify which companies your competitors are placing candidates at
- **B2B SaaS sales teams** - find companies that just raised funding or opened new offices
- **Management consultancies** - track which firms your competitors are engaged with
- **Marketing agencies** - find brands entering new markets or launching new products
- **Staffing firms** - monitor hiring signals across a specific geography or sector

---

### Why it's different: smart job deduplication

Most scraping tools re-process everything every run. This Actor doesn't.

On the first run for each competitor URL, it saves a fingerprint of every job listing. On every subsequent run, it compares the current listings against those fingerprints and **only analyzes new jobs** - ones that appeared since the last run.

This means:
- A competitor with 200 live jobs costs the same to monitor weekly as one with 20 jobs
- You only get notified about genuinely new client engagements
- Your results feed only contains fresh discoveries - existing jobs are filtered out so you're never re-notified about the same competitor engagement twice

The baseline persists across runs indefinitely and survives between weekly and daily schedules.

---

### What it does

#### Competitor job board monitor

Recruitment agencies, consulting firms, and B2B service providers post jobs on behalf of their clients. The descriptions are often copied directly from the client's internal posting - and those sentences are traceable.

The job board scraper crawls competitor career pages, detects new listings since the last run, and uses AI to infer which end client each job was posted for.

**Example output (Asia):**
> Robert Walters Thailand posted a new Senior Java Developer role. Based on the language and tech stack, the end client is likely **Accenture Thailand**. Confidence: high.

**Example output (Europe):**
> Michael Page Germany posted a new SAP Consultant role. Based on the job description, the end client is likely **Deutsche Telekom**. Confidence: medium.

**Example output (US):**
> Robert Half posted a new Staff Accountant role. Based on the description language and sector, the end client is likely **Deloitte US**. Confidence: high.

If a site blocks the initial request, the Actor automatically retries with a residential proxy - no extra config needed.

#### News signal monitor

Run daily searches across Google News for signals that a company in your target industry is about to hire. Funding announcements, office openings, acquisitions, and expansions all get scored 1–10 by AI. Only articles above your chosen threshold (default: 7) appear in the output.

**Example output (Asia):**
> SCB Tech Group announced a 200-person engineering hub in Bangkok. Score: **9/10** - direct expansion signal for IT hiring.

**Example output (Europe):**
> Zalando announced it is expanding its engineering hub in Berlin with 500 new hires. Score: **9/10** - direct hiring signal for tech recruitment.

**Example output (US):**
> Stripe raised a $600M Series I and announced plans to double its engineering team. Score: **10/10** - confirmed funding and headcount expansion.

#### Analyze job boards + news signals (default)

Run both workflows in a single Actor run and get a unified dataset.

---

### Pricing

Pay Per Event - you only pay for what gets processed.

| Plan | Job board analyzed | News article scored |
|---|---|---|
| Free | $80 / 1,000 | $20 / 1,000 |
| Starter | $50 / 1,000 | $10 / 1,000 |
| Scale | $40 / 1,000 | $8 / 1,000 |
| Business+ | $30 / 1,000 | $6 / 1,000 |

Actor start costs $0.05 / 1,000 runs (negligible).

**Typical monthly cost (Starter plan):**
- 5 competitor job boards monitored weekly: ~$1/month
- 20 news articles scored daily: ~$6/month
- **Total: ~$7/month** - a fraction of Apollo ($49+/mo) or Sales Navigator ($99+/mo)

The smart deduplication keeps job board monitoring costs flat regardless of how many jobs a site has. You pay to monitor, not to re-analyze jobs you've already seen.

---

### Setup

1. Open the Actor in Apify Console
2. Set **Competitor career page URLs** - add the career pages of the companies you want to monitor
3. Set **Industry** (for example: IT, fintech, healthcare) and **Geography** - use the full country or region name for best results (for example: Thailand, United States, Germany, United Kingdom, Southeast Asia)
4. Choose **Signal categories**: funding, expansion, hiring, joint venture, new office
5. Click **Start**

No API key required. The Actor works immediately.

---

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `both` | `both` (job boards + news), `competitor_jobs`, or `news_signals` |
| `competitorUrls` | string[] | example pre-filled | Career page URLs to monitor |
| `industry` | string | `IT` | Industry for news searches |
| `geography` | string | `Thailand` | Target geography for news |
| `signalCategories` | string[] | all 5 | Signal types to track |
| `minSignalScore` | integer | `7` | Minimum score (1–10) for news articles |
| `maxArticlesPerQuery` | integer | `10` | Max articles fetched per search query |

---

### Output schema

**Competitor job result** — `score` reflects AI confidence that the job belongs to an end client (9 = high, 6 = medium, 3 = low):

```json
{
  "source": "competitor_jobs",
  "company": "Accenture Thailand",
  "signalType": "client_of_competitor",
  "score": 9,
  "reason": "Job description language and tech stack match Accenture's hiring patterns in Thailand",
  "sourceUrl": "https://www.robertwalters.co.th/jobs/senior-java-developer-123",
  "competitorName": "robertwalters.co.th",
  "jobTitle": "Senior Java Developer",
  "dateFound": "2026-05-28",
  "isNew": true
}
````

**News signal result** — `score` is a direct 1–10 hiring signal rating (7+ recommended threshold, 9–10 = confirmed expansion or funding):

```json
{
  "source": "news",
  "company": "SCB Tech Group",
  "signalType": "expansion",
  "score": 9,
  "reason": "Announced 200-person engineering hub in Bangkok - direct hiring signal",
  "sourceUrl": "https://www.bangkokpost.com/...",
  "competitorName": null,
  "jobTitle": null,
  "dateFound": "2026-05-28",
  "isNew": true
}
```

If no new signals are found in a run, a single summary entry is pushed so the dataset is never empty (`signalType: "no_new_signals"`). If a competitor site fails to load, an error entry is pushed for that URL instead.

***

### How the baseline works

The first time you run the Actor against a competitor URL, it crawls the page, analyzes all current job listings with AI, and saves a fingerprint of each one. You get an immediate full snapshot of your competitors' current client portfolio.

From the second run onwards, only listings with hashes **not seen before** get analyzed. The baseline grows over time, so each run only surfaces what's genuinely new since the last one - you're never shown the same intelligence twice.

This is intentional: a competitor posting 200 jobs that haven't changed costs the same as a competitor with 5 jobs. You pay to monitor, not to re-analyze.

***

### FAQ

**Do I need an API key?**
No. The Actor works out of the box with no configuration.

**How often should I run it?**
Competitor job boards: weekly. News signals: daily. Set up Apify Scheduler on the Actor to automate both.

**What happens on the first run for a competitor URL?**
The Actor analyzes all current job listings and gives you a full snapshot of your competitors' existing client portfolio. From the second run onwards, only new listings are analyzed - so your feed stays fresh without repeats.

**What if a competitor site blocks the crawler?**
The Actor automatically retries with a residential proxy. If the site still fails, the URL appears in the output with `signalType: "error"` so you know which ones need attention. Residential proxy cost is billed by Apify separately from Actor fees.

**Can I use this for industries other than recruitment?**
Yes. The news signal monitor works for any B2B industry and geography. The competitor job board feature is most useful for service businesses where competitors post client work publicly.

# Actor input Schema

## `mode` (type: `string`):

Which workflow to run. 'competitor\_jobs' crawls competitor career pages to identify their clients. 'news\_signals' scans Google News for hiring signals in your industry. 'both' runs both workflows together.

## `competitorUrls` (type: `array`):

Career page URLs of competitors to monitor weekly. Examples: michaelpage.co.th/jobs (Asia), robertwalters.co.uk/jobs (UK), michaelpage.de/jobs (Germany), roberthalf.com/us/en/jobs (US). Replace the pre-filled example with your actual competitors.

## `industry` (type: `string`):

Industry sector used to build news signal queries. Examples: IT, fintech, healthcare, manufacturing, logistics, e-commerce. Only used in news\_signals mode.

## `geography` (type: `string`):

Country, region, or city to focus news searches on. Use full names for best results. Examples: United States, Germany, United Kingdom, Thailand, Southeast Asia, New York, Berlin, Singapore. Only used in news\_signals mode.

## `signalCategories` (type: `array`):

Types of company activity to watch for. All five are pre-filled - remove any you don't need. Options: funding (investment rounds), expansion (new markets/offices), hiring (direct announcements), joint\_venture (partnerships), new\_office (location openings). Only used in news\_signals mode.

## `minSignalScore` (type: `integer`):

Minimum signal strength to include (1–10). 5 = broad (leadership changes), 7 = recommended (confirmed expansions and funding), 9 = strict (direct hiring announcements only). Default 7 is a good starting point.

## `maxArticlesPerQuery` (type: `integer`):

Maximum number of articles to fetch per search query. One query is run per signal category, so the total articles fetched is this number multiplied by the number of active signal categories. Lower = faster and cheaper.

## Actor input object example

```json
{
  "mode": "both",
  "competitorUrls": [
    "https://www.michaelpage.co.th/jobs"
  ],
  "industry": "IT",
  "geography": "Thailand",
  "signalCategories": [
    "funding",
    "expansion",
    "hiring",
    "joint_venture",
    "new_office"
  ],
  "minSignalScore": 7,
  "maxArticlesPerQuery": 10
}
```

# Actor output Schema

## `results` (type: `string`):

All identified signals with company, signal type, score, and source.

# 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 = {
    "competitorUrls": [
        "https://www.michaelpage.co.th/jobs"
    ],
    "industry": "IT",
    "geography": "Thailand",
    "signalCategories": [
        "funding",
        "expansion",
        "hiring",
        "joint_venture",
        "new_office"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("phantom_coder/hiring-signal-monitor").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 = {
    "competitorUrls": ["https://www.michaelpage.co.th/jobs"],
    "industry": "IT",
    "geography": "Thailand",
    "signalCategories": [
        "funding",
        "expansion",
        "hiring",
        "joint_venture",
        "new_office",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("phantom_coder/hiring-signal-monitor").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 '{
  "competitorUrls": [
    "https://www.michaelpage.co.th/jobs"
  ],
  "industry": "IT",
  "geography": "Thailand",
  "signalCategories": [
    "funding",
    "expansion",
    "hiring",
    "joint_venture",
    "new_office"
  ]
}' |
apify call phantom_coder/hiring-signal-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=phantom_coder/hiring-signal-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hiring Signal Monitor",
        "description": "Monitor competitor job boards weekly to reverse-engineer their clients and hiring patterns. Track Google News daily for funding events and office expansions. Identify companies with hiring intent and expansion plans. Built for B2B sales teams, staffing agencies, and management consultancies.",
        "version": "0.1",
        "x-build-id": "oHQB5W6nKkQ38Zzl6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/phantom_coder~hiring-signal-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-phantom_coder-hiring-signal-monitor",
                "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/phantom_coder~hiring-signal-monitor/runs": {
            "post": {
                "operationId": "runs-sync-phantom_coder-hiring-signal-monitor",
                "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/phantom_coder~hiring-signal-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-phantom_coder-hiring-signal-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "🔄 Mode",
                        "enum": [
                            "both",
                            "competitor_jobs",
                            "news_signals"
                        ],
                        "type": "string",
                        "description": "Which workflow to run. 'competitor_jobs' crawls competitor career pages to identify their clients. 'news_signals' scans Google News for hiring signals in your industry. 'both' runs both workflows together.",
                        "default": "both"
                    },
                    "competitorUrls": {
                        "title": "🏢 Competitor career page URLs",
                        "type": "array",
                        "description": "Career page URLs of competitors to monitor weekly. Examples: michaelpage.co.th/jobs (Asia), robertwalters.co.uk/jobs (UK), michaelpage.de/jobs (Germany), roberthalf.com/us/en/jobs (US). Replace the pre-filled example with your actual competitors.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "industry": {
                        "title": "🏭 Industry",
                        "type": "string",
                        "description": "Industry sector used to build news signal queries. Examples: IT, fintech, healthcare, manufacturing, logistics, e-commerce. Only used in news_signals mode.",
                        "default": "IT"
                    },
                    "geography": {
                        "title": "🌍 Geography",
                        "type": "string",
                        "description": "Country, region, or city to focus news searches on. Use full names for best results. Examples: United States, Germany, United Kingdom, Thailand, Southeast Asia, New York, Berlin, Singapore. Only used in news_signals mode.",
                        "default": "Thailand"
                    },
                    "signalCategories": {
                        "title": "📡 Signal categories",
                        "type": "array",
                        "description": "Types of company activity to watch for. All five are pre-filled - remove any you don't need. Options: funding (investment rounds), expansion (new markets/offices), hiring (direct announcements), joint_venture (partnerships), new_office (location openings). Only used in news_signals mode.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "funding",
                            "expansion",
                            "hiring",
                            "joint_venture",
                            "new_office"
                        ]
                    },
                    "minSignalScore": {
                        "title": "🎯 Minimum signal score (1–10)",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Minimum signal strength to include (1–10). 5 = broad (leadership changes), 7 = recommended (confirmed expansions and funding), 9 = strict (direct hiring announcements only). Default 7 is a good starting point.",
                        "default": 7
                    },
                    "maxArticlesPerQuery": {
                        "title": "📰 Max articles per query",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Maximum number of articles to fetch per search query. One query is run per signal category, so the total articles fetched is this number multiplied by the number of active signal categories. Lower = faster and cheaper.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
