# SignalRadar (`rexreus/signalradar`) Actor

Smart competitor tracking built for AI Agents! SignalRadar monitors pricing, jobs, & product changes without the noise. Access structured JSON-LD data and markdown briefs directly in your IDE (Cursor/Windsurf) using the Model Context Protocol (MCP) server. Cost-effective & fast!

- **URL**: https://apify.com/rexreus/signalradar.md
- **Developed by:** [REXREUS D.O](https://apify.com/rexreus) (community)
- **Categories:** AI, MCP servers, E-commerce
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 company intelligence briefs

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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

## 📡 SignalRadar: Change & Entity Intelligence Platform

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-FF8C00?style=for-the-badge&logo=apify&logoColor=white)](https://apify.com)
[![Model Context Protocol](https://img.shields.io/badge/MCP-Compatible-blue?style=for-the-badge)](https://modelcontextprotocol.io)
[![TypeScript](https://img.shields.io/badge/TypeScript-5.0-blue?style=for-the-badge&logo=typescript&logoColor=white)](https://www.typescriptlang.org)
[![License: MIT](https://img.shields.io/badge/License-MIT-green?style=for-the-badge)](https://opensource.org/licenses/MIT)

<p>
<img src="https://i.imgur.com/kBYQ1Z3.png" align="center">
</p>

SignalRadar is an enterprise-grade Change Intelligence platform that tracks, parses, and highlights key updates (pricing grids, changelogs, career boards, news) across target company websites. It is built using a decoupled architecture combining a high-performance **Apify Actor** (scraping and diffing engine) and a stateless **Model Context Protocol (MCP) Server** (access and query gateway).

Designed for sales teams, investors, and AI agents, SignalRadar optimizes data extraction costs and LLM context windows using cache-first routing, semantic token-saving output options, and automatic change noise reduction.

---

### 🏗️ Platform Architecture

```mermaid
graph TD
    subgraph AI Client / IDE
        Cursor[Cursor / Windsurf / Custom Agent]
    end

    subgraph Apify Cloud Platform
        Actor[SignalRadar Actor / MCP Server]
        KV[Key-Value Snapshot Store]
        Dataset[Runs Dataset]
    end

    subgraph Competitor Web Targets
        Site1[Pricing Pages]
        Site2[Greenhouse / Job Boards]
        Site3[RSS Changelogs]
    end

    Cursor <-->|Stdio (CLI Bridge) / SSE| Actor
    Actor <-->|ETag / 304 Check| KV
    Actor -->|Append Briefs| Dataset
    Actor <-->|HTTP / Playwright| Site1
    Actor <-->|Direct API Fetch| Site2
    Actor <-->|RSS Parsing| Site3
````

***

### 🚀 Key Features

- **HTTP-First Scraping Strategy**: Utilizes lightweight Axios/Cheerio default adapters to bypass heavy browser processes, keeping container memory **<100MB** for 90% of requests. Fallbacks to headless Playwright browsers occur only when dynamic JS or captchas require it.
- **Cache-First Latency Budget**: Serves rapid historical queries under **200 milliseconds** from pre-scraped Apify stores, preventing downstream AI client timeouts.
- **Token-Aware Output Formatters**: Supports three distinct output modes (`brief`, `detailed`, `visual-link`) allowing AI agents to request condensed updates and save up to **75% in context token costs**.
- **Semantic Schema.org JSON-LD**: Outputs change records structured under standard JSON-LD schemas (`@type: "Organization"`, `@type: "UpdateAction"`, `PriceSpecification`) for plug-and-play AI integrations.
- **Scroll-to-Text Evidence Links**: Generates exact highlight URLs using Google's Scroll-to-Text Fragment parameters (e.g. `#:~:text=`) pointing directly to changes on the live web target.
- **Public Dashboard & Status Badges**: Generates visual EJS HTML timeline dashboards (`dashboard.html`) and live SVG health badges (e.g. `stripe-pricing-green.svg`) stored with public read access.
- **Noise-Free Diff Engine**: Strips boilerplate banners, GDPR overlays, headers, and analytics tracking scripts. Leverages Levenshtein distance calculations to mute trivial typo adjustments (<3% paragraph edits).
- **Wayback Machine Fallback**: Automatically requests archived snapshots from the Internet Archive Wayback Machine if live targets enforce aggressive Cloudflare blocks on a new target.

***

### 💎 Advanced Features & Capabilities

SignalRadar is designed to deliver maximum business value with minimum compute and proxy overhead. Here is a detailed look at the advanced capabilities built into the platform:

#### 📈 1. Intelligent Pricing Intelligence

- **Structured Pricing Table Parsing**: Automatically extracts and maps raw pricing grids into normalized JSON key-value pairs (e.g. `{"Free": 0, "Pro": 15}`).
- **Hydration Script Parsing**: Directly extracts React hydration state JSON (from `<script id="__NEXT_DATA__">` or Nuxt state window objects) of single-page apps, getting 100% accurate price points without running expensive browser engines.
- **Price Change Scoring**: Evaluates changes deterministically, flagging modified plans and generating relevance alerts.

#### 💼 2. Career & Job Board Tracking

- **Native API Interception**: Detects if a company uses major job boards like Greenhouse or Lever. It bypasses the website altogether, fetching the job data directly from Greenhouse/Lever JSON REST endpoints.
- **Frictionless Scrapes**: Bypasses anti-bot challenges and browser overhead, providing lightweight, structured additions and removals of career posts.

#### 🔄 3. Changelog & Product Feed Monitoring

- **RSS/Sitemap Priority**: Automatically checks for RSS feeds or XML sitemap updates before scraping html pages. This extracts changelog posts in milliseconds with zero false positives.
- **Wayback Machine Fallback**: If a target site implements severe Cloudflare CAPTCHAs and has no scraping history, the Actor queries the Internet Archive Wayback Machine to extract the latest snapshot.

#### 📢 4. Noise-Filtering & Diff Muting

- **Dynamic Tag Stripping**: Automatically strips boilerplate HTML elements (cookie consent alerts, site navigation bars, footers, ad iframe nodes, tracking scripts) before computing diffs.
- **Typo Muting**: Calculates the Levenshtein distance of modifications. If the edit distance is less than 3% of the paragraph size, the update is muted to prevent alert spam from simple typo fixes.
- **Redesign Consolidation**: If more than 80% of a page's text changes, the Actor groups all updates into a single `WEBSITE_REDESIGN_OR_REBRAND` signal instead of triggering dozens of noise alerts.

#### 🚀 5. Performance & Resource Optimization

- **HTTP Conditional Requests**: Stores ETag and Last-Modified headers from previous scrapes. If subsequent fetches return `304 Not Modified`, it immediately skips parsing and diff calculations, saving up to **90% in proxy bandwidth**.
- **Request Ad-Blocking**: Intercepts requests during browser fallbacks, blocking ads and tracking endpoints (Segment, Google Analytics, Sentry, Mixpanel) to shave off another 30% of bandwidth.
- **OOM Preventative Memory Auto-Tuning**: Detects container allocation RAM. If below 512MB, it automatically disables Playwright browser fallbacks and routes queries to Wayback Machine backups, preventing container crashes.

***

### 🤖 AI Client & Agent Integration

You can connect your local AI development environments (like Cursor or Windsurf), desktop clients (like OpenClaw), or autonomous agent frameworks (like Hermes) directly to the SignalRadar Actor running on Apify.

#### A. Connecting Cursor / Windsurf IDE

To connect Cursor or Windsurf directly to your cloud-hosted Apify Actor, configure them to use the Apify CLI as a local Stdio-to-Cloud proxy bridge.

1. Open Cursor/Windsurf and navigate to **Settings** > **Models** > **MCP**.
2. Click **+ Add New MCP Server**.
3. Configure the following fields:
   - **Name**: `SignalRadar`
   - **Type**: `command`
   - **Command**: `npx @apify/cli actor:run-mcp -a rexreus/SignalRadar -t <YOUR_APIFY_TOKEN>`

***

#### B. Connecting Hermes & OpenClaw

For agent frameworks like **Hermes** or desktop interfaces like **OpenClaw**, you can integrate SignalRadar using either the Stdio bridge configuration or the SSE endpoint.

##### 1. Stdio Configuration (`mcp-servers.json` / `config.json`)

Add the following to your agent framework's MCP config file:

```json
{
  "mcpServers": {
    "signal-radar": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/cli",
        "actor:run-mcp",
        "-a",
        "rexreus/SignalRadar",
        "-t",
        "<YOUR_APIFY_TOKEN>"
      ]
    }
  }
}
```

##### 2. SSE Configuration (Remote Web Server Client)

If your framework supports remote SSE servers, start the Actor run on Apify and connect using the container SSE endpoint:

```json
{
  "mcpServers": {
    "signal-radar": {
      "url": "https://<your-actor-run-id>.runs.apify.net/sse",
      "headers": {
        "Authorization": "Bearer <YOUR_APIFY_TOKEN>"
      }
    }
  }
}
```

***

#### 📋 Concrete AI Agent Task Examples

Once SignalRadar is connected to your agent (Hermes, OpenClaw, or Cursor), you can assign it tasks using natural language. The agent will automatically select the appropriate tools to fulfill the request.

##### Task Example 1: Track Competitor Pricing Changes (Relevance Score > 7)

- **User Prompt**: *"Check if Stripe has changed their pricing plans in the last 7 days. I only care about high-relevance modifications with a change score of 7 or higher. Summarize the changes briefly."*
- **Agent Execution Path**:
  1. Calls `get_recent_changes` with arguments: `{"domain": "stripe.com", "category": "pricing", "minScore": 7, "outputFormat": "brief"}`.
  2. Synthesizes the response for the user: *"Yes, Stripe modified their Pro plan from $10 to $15. You can view the highlight evidence here: https://stripe.com/pricing#:~:text=Pro%20plan%20is%20now%20%2415."*

##### Task Example 2: Monitor Career Openings for AI Roles

- **User Prompt**: *"Check if Anthropic has posted any new Senior Machine Learning Engineer jobs on their careers board recently."*
- **Agent Execution Path**:
  1. Calls `get_recent_changes` with arguments: `{"domain": "anthropic.com", "category": "jobs", "outputFormat": "brief"}`.
  2. Compares the results and returns details of newly posted roles.

##### Task Example 3: Full Company Intelligence Audit & Score

- **User Prompt**: *"Run a full business change intelligence audit for openai.com. I want to see their calculated opportunity and risk scores, along with explanations for the scores."*
- **Agent Execution Path**:
  1. Calls `run_brief` with arguments: `{"domain": "openai.com"}` (starts background scrape on Apify).
  2. Calls `wait_for_brief` to await completion.
  3. Calls `get_signal_score` with arguments: `{"domain": "openai.com"}`.
  4. Returns the risk breakdown, opportunity ranking, and visual dashboard link (`visualBriefUrl`).

#### 💡 Saving Token Budget (`outputFormat`)

When communicating with AI agents, choose the appropriate `outputFormat` argument to control cost vs. detail:

1. **`brief` (Default)**: Returns highly condensed, semantic sentence outlines of updates. Excellent for keeping LLM prompts lightweight.
   ```json
   {
     "changes": [
       "[Pricing] Changed Pro Plan from $10 to $15 (Score: 8/10) - Evidence: https://stripe.com/pricing#:~:text=Pro%20plan%20is%20now%20%2415"
     ]
   }
   ```
2. **`visual-link`**: Returns only the dashboard URL link. Reduces context size to near-zero.
   ```json
   {
     "visualBriefUrl": "https://api.apify.com/v2/key-value-stores/store-id/records/dashboard-stripe.html",
     "message": "Detailed changes can be viewed visually on the SignalRadar public web dashboard."
   }
   ```
3. **`detailed`**: Returns the complete Schema.org JSON-LD object containing detailed diff text maps. Use this only when you need programmatic access to raw text segments.

***

### 🛠️ MCP Tools Reference

SignalRadar exposes the following tools to connected clients:

| Tool Name | Parameters | Description |
| :--- | :--- | :--- |
| `list_sources` | None | Returns the list of active source adapters (e.g. `website`, `pricing`, `jobs`, `changelog`, `news`). |
| `create_watchlist` | `domains` (array of strings, required)<br>`adapters` (array of strings, optional)<br>`webhookUrl` (string, optional) | Registers a new company or set of domains to monitor. Normalizes URLs to apex domains. |
| `run_brief` | `domain` (string, required)<br>`maxAgeSeconds` (integer, optional) | Triggers a background scraping execution on the Apify platform for the entity. Returns a `runId`. |
| `get_recent_changes` | `domain` (string, required)<br>`category` (string, optional)<br>`minScore` (integer, optional)<br>`outputFormat` (string, optional) | Retrieves detected changes from cache. Returns instantly (<200ms). |
| `get_evidence_pack` | `changeId` (string, required) | Returns source HTML quotes, text diff blocks, and Scroll-to-Text fragment links for a specific change. |
| `get_signal_score` | `domain` (string, required) | Returns computed risk and opportunity scores alongside qualitative business explanations. |
| `wait_for_brief` | `runId` (string, required) | Blocks and polls the Apify Actor status every 2 seconds for up to 15 seconds to return the completed brief. |
| `search_watchlists`| `query` (string, required) | Performs a text search on registered watchlists, saving token budget. |
| `diagnostic_health_check` | None | Evaluates Apify credentials validity, checks remaining platform credits, and tests proxy connectivity. |

***

### ⚙️ Technical Highlights

#### ⚡ Conditional Fetching & ETag Support

During Axios page fetching, the scraper persists and sends `If-None-Match` (ETag) and `If-Modified-Since` (Last-Modified) headers. If target servers return a `304 Not Modified` status, SignalRadar immediately skips the diffing, parsing, and data-writing cycles, saving up to **90% in proxy bandwidth costs**.

#### 🛡️ CAPTCHA & Security Mitigation

- Spoofs TLS fingerprints (ALPN settings, ciphers matching Chrome/Safari) inside raw HTTP requests.
- PROXY-resolved DNS: Performs hostname lookups on the proxy server via CONNECT tunnels, escaping data center DNS blacklists.
- Intercepts and blocks analytics trackers, double-click ads, and video resources during browser fallbacks to reduce proxy bandwidth by another ~30%.

***

### 📄 License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

# Actor input Schema

## `domain` (type: `string`):

The apex domain of the target company (e.g. stripe.com).

## `adapters` (type: `array`):

Select the change adapters to run.

## `webhookUrl` (type: `string`):

A destination URL (e.g. Slack/Discord webhook or back-end API) to receive markdown alerts if changes are detected.

## `maxAgeSeconds` (type: `integer`):

Skip live scraping if a cached brief exists that is newer than this value. Set to 0 to bypass cache and force a live scrape.

## `ignoreRobotsRules` (type: `boolean`):

Set to true to scrape pages even if robots.txt restricts automated access.

## Actor input object example

```json
{
  "domain": "stripe.com",
  "adapters": [
    "website",
    "pricing"
  ],
  "maxAgeSeconds": 86400,
  "ignoreRobotsRules": false
}
```

# Actor output Schema

## `brief` (type: `string`):

Formatted summary of detected competitor changes.

# 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 = {
    "domain": "stripe.com",
    "adapters": [
        "website",
        "pricing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("rexreus/signalradar").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 = {
    "domain": "stripe.com",
    "adapters": [
        "website",
        "pricing",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("rexreus/signalradar").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 '{
  "domain": "stripe.com",
  "adapters": [
    "website",
    "pricing"
  ]
}' |
apify call rexreus/signalradar --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SignalRadar",
        "description": "Smart competitor tracking built for AI Agents! SignalRadar monitors pricing, jobs, & product changes without the noise. Access structured JSON-LD data and markdown briefs directly in your IDE (Cursor/Windsurf) using the Model Context Protocol (MCP) server. Cost-effective & fast!",
        "version": "0.0",
        "x-build-id": "PrUufoLkhg3im9hcg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rexreus~signalradar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rexreus-signalradar",
                "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/rexreus~signalradar/runs": {
            "post": {
                "operationId": "runs-sync-rexreus-signalradar",
                "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/rexreus~signalradar/run-sync": {
            "post": {
                "operationId": "run-sync-rexreus-signalradar",
                "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": [
                    "domain"
                ],
                "properties": {
                    "domain": {
                        "title": "Target Domain",
                        "type": "string",
                        "description": "The apex domain of the target company (e.g. stripe.com)."
                    },
                    "adapters": {
                        "title": "Active Adapters",
                        "type": "array",
                        "description": "Select the change adapters to run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "webhookUrl": {
                        "title": "Webhook Notification URL",
                        "type": "string",
                        "description": "A destination URL (e.g. Slack/Discord webhook or back-end API) to receive markdown alerts if changes are detected."
                    },
                    "maxAgeSeconds": {
                        "title": "Max Cache Age (seconds)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip live scraping if a cached brief exists that is newer than this value. Set to 0 to bypass cache and force a live scrape.",
                        "default": 86400
                    },
                    "ignoreRobotsRules": {
                        "title": "Ignore robots.txt",
                        "type": "boolean",
                        "description": "Set to true to scrape pages even if robots.txt restricts automated access.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```