# Buyer Intent Radar (`dori1/devops-buyer-intent-radar`) Actor

Find sales-ready public buyer-intent signals and turn them into proof packs, offer experiments, outreach drafts, CSV, JSON, SQLite, and an engagement dashboard.

- **URL**: https://apify.com/dori1/devops-buyer-intent-radar.md
- **Developed by:** [Doron Aloni](https://apify.com/dori1) (community)
- **Categories:** Lead generation, Marketing, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Buyer Intent Radar

Find public intent signals from people or companies likely to care about a
specific product. Terraform Guard is the first target product, but the radar is
now market-agnostic: change the product, market description, keywords, intent
terms, and sources without changing code.

- technical sources such as GitHub repositories, GitHub issues, and Hacker News
- known company domains, direct public page URLs, and RSS/Atom feeds
- manually supplied evidence snippets from any allowed source
- configurable positive intent terms and negative-noise filters

The Actor returns ranked leads with evidence URLs, intent scores, proof packs,
recommended angles, and human-approved outreach drafts. It also adds a market
intelligence brief with buyer moments, source quality, offer experiments, next
actions, and a closed-loop learning path.

It is a signal-to-lead intelligence workflow, not just a scraper. Scraping only
collects pages. This Actor turns public evidence into a ranked commercial
signal: who to inspect, why now, what proof offer to test, which evidence would
close the loop, and what repeated product gap should become the next feature or
Actor.

### Why this exists

Terraform Guard is already published on Apify, but discovery is the missing
piece. This Actor is the demand engine: find teams with public evidence of
Terraform, platform engineering, CI, cloud security, and AI-agent workflow needs,
then produce a clean lead list you can review before outreach.

The same engine can scan another field, for example restaurants, recruiting,
real estate, e-commerce, healthcare ops, or SaaS competitors, as long as the user
provides the right keywords and public sources.

### Local usage

```bash
pip install -e ".[dev]"
devops-buyer-intent-radar --max-results 10
````

With manual evidence:

```bash
devops-buyer-intent-radar --manual-signal "ExampleCo|https://example.com/jobs|Hiring platform engineers for Terraform and CI/CD"
```

Generate a visual report, Excel-openable CSV, and SQLite database:

```bash
devops-buyer-intent-radar \
  --source github_repositories \
  --keyword terraform \
  --keyword opentofu \
  --keyword atlantis \
  --max-results 25 \
  --min-score 35 \
  --report-dir outputs/terraform-guard
```

Preview mode caps output to 3 leads and skips this Actor's pay-per-event
charges. Platform usage costs may still apply depending on Apify billing
settings:

```bash
devops-buyer-intent-radar --preview-mode --source github_repositories --keyword terraform
```

By default the Actor hides weak proof packs and high disqualification risks.
Use research mode only when you want broader market exploration instead of a
sales-ready shortlist:

```bash
devops-buyer-intent-radar --include-weak-signals --source github_issues --keyword terraform
```

Use it for Kubernetes or another market by changing keywords:

```bash
devops-buyer-intent-radar \
  --product-name "Kubernetes Visual Trainer" \
  --market "Interactive Kubernetes and CKA training workspace." \
  --keyword kubernetes \
  --keyword helm \
  --keyword cka \
  --keyword platform-engineering \
  --report-dir outputs/kubernetes-trainer
```

Use it outside DevOps by adding market-specific intent terms and generic public
sources:

```bash
devops-buyer-intent-radar \
  --product-name "Restaurant Booking Radar" \
  --product-url "https://example.com/booking-radar" \
  --market "Restaurants with waitlist, reservation, and booking workflow pain." \
  --keyword restaurant \
  --keyword waitlist \
  --keyword reservation \
  --intent-term "looking for" \
  --intent-term integration \
  --intent-term "manual booking" \
  --source manual_signals \
  --manual-signal "Bistro Ops|https://bistro.example/jobs|Restaurant team looking for waitlist integration and booking workflow automation."
```

The `autoExpandKeywords` option derives extra search and scoring terms from the
product name, market, and contact persona. The output includes `researchScope`
so the user can see which sources, keywords, expanded keywords, intent terms,
and negative filters were used.

### Outputs

- Apify Dataset rows: one row per sales-ready lead by default, exportable from Apify.
- Key-value store `OUTPUT`: complete JSON summary.
- Key-value store `RADAR_REPORT_HTML`: visual lead report with Market Intelligence Brief and per-lead Proof Pack.
- Key-value store `ENGAGEMENT_DASHBOARD_HTML`: local-first workflow dashboard for editing outreach and tracking replies.
- Key-value store `RADAR_LEADS_CSV`: spreadsheet-friendly lead export with buyer moment, urgency, proof strength, micro-offer, and next action.
- Local CLI: optional report HTML, engagement dashboard HTML, CSV, JSON, and SQLite exports.

The engagement dashboard opens Gmail, Outlook Web, or the local mail client with
the edited draft. Replies still arrive in the channel used to send the message;
the dashboard stores follow-up state in browser local storage and can export the
current engagement tracker to CSV or JSON.

### MCP

Run the local MCP server:

```bash
devops-buyer-intent-radar-mcp
```

MCP tools:

- `buyer_intent_radar_run`
- `buyer_intent_record_event`
- `buyer_intent_sample_inputs`

See `docs/MCP_USAGE.md` for Codex/Claude Code configuration.

### Apify input

```json
{
  "productName": "Terraform Guard",
  "productUrl": "https://apify.com/dori1/terraform-guard",
  "keywords": ["terraform", "opentofu", "atlantis", "platform engineering"],
  "intentTerms": ["security", "compliance", "approval", "guardrail", "automation"],
  "requiredTerms": ["terraform", "opentofu", "terragrunt", "infrastructure-as-code"],
  "negativeKeywords": ["student tutorial"],
  "sources": ["github_repositories", "github_issues", "hackernews"],
  "maxResults": 25,
  "salesReadyOnly": true,
  "includeOutreachDrafts": true
}
```

### Pay-per-event hooks

The Actor is wired for:

- `intent-radar-run`
- `qualified-lead`

Keep publishing conservative until real cost is measured from 5 to 10 Apify runs.
The current local recommendation is `$1.00` per run plus `$0.10` per qualified
lead, because the result is concrete data in the dataset and includes report,
CSV, dashboard, and outreach drafts.

### Outreach policy

This Actor drafts messages. It does not auto-send messages, post to social
media, or contact prospects. That keeps the workflow compliant and protects the
creator identity: every public action should be reviewed and approved by a human.

# Actor input Schema

## `productName` (type: `string`):

Product to promote in outreach drafts.

## `productUrl` (type: `string`):

Public landing page or Apify Store URL.

## `market` (type: `string`):

Short positioning context used when drafting outreach.

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

Public sources to scan. Supported values: github\_repositories, github\_issues, hackernews, seed\_domains, page\_urls, rss\_feeds, manual\_signals.

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

Buyer-intent terms to search and score.

## `autoExpandKeywords` (type: `boolean`):

Derive additional search/scoring terms from product name, market, and contact persona so the radar can adapt to new fields without code changes.

## `intentTerms` (type: `array`):

Optional phrases that imply evaluation, pain, buying, hiring, integration, or urgency in this market.

## `requiredTerms` (type: `array`):

Optional terms where at least one must appear in a signal before it can qualify. Use this to avoid ambiguous keywords such as Atlantis matching unrelated markets.

## `negativeKeywords` (type: `array`):

Terms that should exclude noisy or unrelated signals.

## `seedDomains` (type: `array`):

Optional company domains to check for public jobs, engineering, blog, docs, or market-specific signals.

## `sourceUrls` (type: `array`):

Optional public page URLs to score directly. Use source page\_urls or leave it blank and it will be added automatically.

## `rssFeeds` (type: `array`):

Optional RSS or Atom feeds to scan for recurring public signals in any market.

## `manualSignals` (type: `array`):

Optional pasted evidence objects for scoring without web discovery.

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

Maximum qualified leads to return.

## `minScore` (type: `integer`):

Only return leads at or above this intent score.

## `includeOutreachDrafts` (type: `boolean`):

Generate human-reviewed email/DM drafts for each lead.

## `salesReadyOnly` (type: `boolean`):

Hide weak proof packs and high disqualification risks by default. Disable for broader market research mode.

## `previewMode` (type: `boolean`):

Caps output to 3 leads and skips this Actor's pay-per-event charges. Platform usage costs may still apply depending on Apify billing settings.

## `contactPersona` (type: `string`):

Persona to address in outreach drafts.

## `replyTo` (type: `string`):

Email, LinkedIn profile, GitHub issue URL, or other destination prospects should reply to. Leave blank if replies should stay in the channel where the message is sent.

## `calendarUrl` (type: `string`):

Optional booking link to include in outreach drafts.

## `trialInstructions` (type: `string`):

Explain how a prospect can test the product before serious usage.

## `githubToken` (type: `string`):

Optional GitHub token to improve API rate limits. It is never returned in output.

## Actor input object example

```json
{
  "productName": "Terraform Guard",
  "productUrl": "https://apify.com/dori1/terraform-guard",
  "market": "Pre-apply Terraform and OpenTofu safety gate for AI coding agents and CI pipelines.",
  "sources": [
    "github_repositories",
    "github_issues",
    "hackernews"
  ],
  "keywords": [
    "terraform",
    "opentofu",
    "terragrunt",
    "atlantis",
    "platform engineering",
    "infrastructure as code",
    "devops"
  ],
  "autoExpandKeywords": true,
  "intentTerms": [
    "security",
    "compliance",
    "approval",
    "guardrail",
    "ci/cd",
    "github actions",
    "production",
    "looking for",
    "recommend",
    "alternative",
    "integration",
    "automation",
    "hiring"
  ],
  "requiredTerms": [],
  "negativeKeywords": [],
  "seedDomains": [],
  "sourceUrls": [],
  "rssFeeds": [],
  "manualSignals": [],
  "maxResults": 25,
  "minScore": 25,
  "includeOutreachDrafts": true,
  "salesReadyOnly": true,
  "previewMode": false,
  "contactPersona": "Head of Platform Engineering",
  "replyTo": "",
  "calendarUrl": "",
  "trialInstructions": "Start with a small Apify run or a provided sample report. Review the scored leads before using it for outreach."
}
```

# Actor output Schema

## `status` (type: `string`):

No description

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("dori1/devops-buyer-intent-radar").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("dori1/devops-buyer-intent-radar").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 '{}' |
apify call dori1/devops-buyer-intent-radar --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Buyer Intent Radar",
        "description": "Find sales-ready public buyer-intent signals and turn them into proof packs, offer experiments, outreach drafts, CSV, JSON, SQLite, and an engagement dashboard.",
        "version": "0.2",
        "x-build-id": "AMLEWg5IAT6ejAz3X"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dori1~devops-buyer-intent-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dori1-devops-buyer-intent-radar",
                "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/dori1~devops-buyer-intent-radar/runs": {
            "post": {
                "operationId": "runs-sync-dori1-devops-buyer-intent-radar",
                "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/dori1~devops-buyer-intent-radar/run-sync": {
            "post": {
                "operationId": "run-sync-dori1-devops-buyer-intent-radar",
                "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": [
                    "productName",
                    "productUrl"
                ],
                "properties": {
                    "productName": {
                        "title": "Product name",
                        "type": "string",
                        "description": "Product to promote in outreach drafts.",
                        "default": "Terraform Guard"
                    },
                    "productUrl": {
                        "title": "Product URL",
                        "type": "string",
                        "description": "Public landing page or Apify Store URL.",
                        "default": "https://apify.com/dori1/terraform-guard"
                    },
                    "market": {
                        "title": "Market",
                        "type": "string",
                        "description": "Short positioning context used when drafting outreach.",
                        "default": "Pre-apply Terraform and OpenTofu safety gate for AI coding agents and CI pipelines."
                    },
                    "sources": {
                        "title": "Sources",
                        "type": "array",
                        "description": "Public sources to scan. Supported values: github_repositories, github_issues, hackernews, seed_domains, page_urls, rss_feeds, manual_signals.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "github_repositories",
                            "github_issues",
                            "hackernews"
                        ]
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Buyer-intent terms to search and score.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "terraform",
                            "opentofu",
                            "terragrunt",
                            "atlantis",
                            "platform engineering",
                            "infrastructure as code",
                            "devops"
                        ]
                    },
                    "autoExpandKeywords": {
                        "title": "Auto-expand keywords",
                        "type": "boolean",
                        "description": "Derive additional search/scoring terms from product name, market, and contact persona so the radar can adapt to new fields without code changes.",
                        "default": true
                    },
                    "intentTerms": {
                        "title": "Intent terms",
                        "type": "array",
                        "description": "Optional phrases that imply evaluation, pain, buying, hiring, integration, or urgency in this market.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "security",
                            "compliance",
                            "approval",
                            "guardrail",
                            "ci/cd",
                            "github actions",
                            "production",
                            "looking for",
                            "recommend",
                            "alternative",
                            "integration",
                            "automation",
                            "hiring"
                        ]
                    },
                    "requiredTerms": {
                        "title": "Required terms",
                        "type": "array",
                        "description": "Optional terms where at least one must appear in a signal before it can qualify. Use this to avoid ambiguous keywords such as Atlantis matching unrelated markets.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "negativeKeywords": {
                        "title": "Negative keywords",
                        "type": "array",
                        "description": "Terms that should exclude noisy or unrelated signals.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "seedDomains": {
                        "title": "Seed domains",
                        "type": "array",
                        "description": "Optional company domains to check for public jobs, engineering, blog, docs, or market-specific signals.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "sourceUrls": {
                        "title": "Source URLs",
                        "type": "array",
                        "description": "Optional public page URLs to score directly. Use source page_urls or leave it blank and it will be added automatically.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "rssFeeds": {
                        "title": "RSS/Atom feeds",
                        "type": "array",
                        "description": "Optional RSS or Atom feeds to scan for recurring public signals in any market.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "manualSignals": {
                        "title": "Manual signals",
                        "type": "array",
                        "description": "Optional pasted evidence objects for scoring without web discovery.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "companyName": {
                                    "title": "Company name",
                                    "type": "string",
                                    "description": "Company, GitHub owner, or prospect label.",
                                    "editor": "textfield"
                                },
                                "sourceUrl": {
                                    "title": "Source URL",
                                    "type": "string",
                                    "description": "Public evidence URL.",
                                    "editor": "textfield"
                                },
                                "text": {
                                    "title": "Signal text",
                                    "type": "string",
                                    "description": "Evidence text to score.",
                                    "editor": "textarea"
                                }
                            }
                        },
                        "default": []
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum qualified leads to return.",
                        "default": 25
                    },
                    "minScore": {
                        "title": "Minimum score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only return leads at or above this intent score.",
                        "default": 25
                    },
                    "includeOutreachDrafts": {
                        "title": "Include outreach drafts",
                        "type": "boolean",
                        "description": "Generate human-reviewed email/DM drafts for each lead.",
                        "default": true
                    },
                    "salesReadyOnly": {
                        "title": "Sales-ready only",
                        "type": "boolean",
                        "description": "Hide weak proof packs and high disqualification risks by default. Disable for broader market research mode.",
                        "default": true
                    },
                    "previewMode": {
                        "title": "Preview mode",
                        "type": "boolean",
                        "description": "Caps output to 3 leads and skips this Actor's pay-per-event charges. Platform usage costs may still apply depending on Apify billing settings.",
                        "default": false
                    },
                    "contactPersona": {
                        "title": "Contact persona",
                        "type": "string",
                        "description": "Persona to address in outreach drafts.",
                        "default": "Head of Platform Engineering"
                    },
                    "replyTo": {
                        "title": "Reply-to contact",
                        "type": "string",
                        "description": "Email, LinkedIn profile, GitHub issue URL, or other destination prospects should reply to. Leave blank if replies should stay in the channel where the message is sent.",
                        "default": ""
                    },
                    "calendarUrl": {
                        "title": "Calendar URL",
                        "type": "string",
                        "description": "Optional booking link to include in outreach drafts.",
                        "default": ""
                    },
                    "trialInstructions": {
                        "title": "Trial instructions",
                        "type": "string",
                        "description": "Explain how a prospect can test the product before serious usage.",
                        "default": "Start with a small Apify run or a provided sample report. Review the scored leads before using it for outreach."
                    },
                    "githubToken": {
                        "title": "GitHub token",
                        "type": "string",
                        "description": "Optional GitHub token to improve API rate limits. It is never returned in output."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
