# Hacker News Developer Sentiment—What Devs Think (MCP Server) (`joeslade/hn-developer-sentiment-mcp`) Actor

Zero setup, no API key: a deterministic read on what developers really think of any tool, library, or brand on Hacker News—sentiment, mention volume, themes, and feature requests across HN stories and comments, via 4 agent-callable MCP tools.

- **URL**: https://apify.com/joeslade/hn-developer-sentiment-mcp.md
- **Developed by:** [Joe Slade](https://apify.com/joeslade) (community)
- **Categories:** Developer tools, AI, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

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

_What developers really think about your tool._

**A deterministic read on Hacker News developer sentiment for any brand, tool, or library** — sentiment, mention volume, recurring themes, and feature requests across HN stories and comments, exposed as **four agent-callable MCP tools**. The differentiator is **judgment and aggregation, not raw access**: it scores, clusters, and mines public HN discussion so an AI agent can act in a single call, and returns the raw matched items alongside the aggregates so every number is auditable.

**Zero setup — no API key.** The Hacker News (Algolia) API is open, so this Actor boots and returns data immediately. No credentials, no approval queue, no first-run friction.

No LLM in the analysis layer — sentiment is a transparent lexicon-plus-rules scorer, so the same posts always produce the same answer.

### Who is this for?

- **AI agents** that need a one-call read on how developers feel about a product before drafting a comparison, a launch post, or a support reply.
- **DevRel and product teams** tracking how a tool, framework, or release is landing with the Hacker News crowd.
- **Founders and marketers** validating positioning against what developers actually say in public.

### Why use Hacker News Developer Sentiment?

- **Zero setup** — no API key, no login, no approval process. Deploy and call.
- **One call, a usable answer** — sentiment label, net score, volume, top themes, and representative samples in a single structured response.
- **Deterministic and auditable** — no model temperature, no per-call drift. Same posts plus same config always produce the same output, and the raw items ship alongside the aggregates.
- **Built for agents** — a Standby MCP server speaking the Streamable HTTP transport, so any MCP client can connect and call it directly.
- **Cheap and fast** — one HN payload per query, cached and shared across the query tools. No LLM cost in the analysis path.

### How to use Hacker News Developer Sentiment

1. **Deploy the Actor** — run it in Standby mode on Apify. It boots with no input required and returns data immediately.
2. **Connect your MCP client** to the Standby endpoint (`https://<your-standby-url>/mcp`) using the Streamable HTTP transport.
3. **Call `get_sentiment_summary`** with a `query` (a brand, tool, or topic) for the headline read.
4. **Drill in** with `search_mentions`, `get_feature_requests`, or `get_trending_discussions` when you need detail. The query tools share the same cached payload per query.

### The four tools

`query` is a brand/tool/topic string (e.g. `"prisma"`, `"tailwind"`). `channels`, `windowDays`, and `limit` are optional and fall back to the Actor's configured defaults. `channels` selects HN post types — `story`, `ask_hn`, `show_hn`, `comment` — and defaults to all (stories **and** comments, since HN opinion lives in the comments).

#### `get_sentiment_summary` — the headline read

Aggregate sentiment, mention volume, top themes, and representative samples for a query. Input: `query` (required), `channels?`, `windowDays?`.

```jsonc
{
  "query": "prisma",
  "channelsQueried": ["story", "ask_hn", "show_hn", "comment"],
  "windowDays": 30,
  "mentionVolume": 52,
  "netSentiment": 0.18,
  "sentimentLabel": "Positive",
  "breakdown": { "positive": 29, "neutral": 16, "negative": 7 },
  "topThemes": [
    { "term": "type safety", "count": 15 },
    { "term": "migrations", "count": 12 },
    { "term": "query performance", "count": 7 }
  ],
  "topSamples": [
    {
      "title": "Prisma 6 made our migrations painless",
      "channel": "story",
      "score": 312,
      "url": "https://news.ycombinator.com/item?id=48800001",
      "createdAt": "2026-06-02T14:11:00.000Z",
      "sentiment": "Positive"
    }
  ],
  "fetchedAt": "2026-07-14T00:00:00.000Z"
}
````

`netSentiment` is the mean compound score in `[-1, 1]`; `sentimentLabel` buckets it at ±0.05. `topSamples` are the three highest-engagement items. `topThemes` are stopword- and query-term-filtered unigrams/bigrams ranked by frequency.

#### `search_mentions` — matched items with per-item sentiment

Stories and comments mentioning the query, each scored, ranked by score then recency. Input: `query` (required), `channels?`, `windowDays?`, `limit?`.

```jsonc
{
  "query": "prisma",
  "channelsQueried": ["story", "comment"],
  "windowDays": 30,
  "count": 2,
  "items": [
    {
      "id": "48800001",
      "title": "Prisma 6 made our migrations painless",
      "excerpt": "We migrated a 40-table schema with zero downtime and the typed client caught three bugs before...",
      "channel": "story",
      "score": 312,
      "numComments": 88,
      "url": "https://news.ycombinator.com/item?id=48800001",
      "createdAt": "2026-06-02T14:11:00.000Z",
      "sentiment": "Positive",
      "sentimentScore": 0.74
    }
  ],
  "fetchedAt": "2026-07-14T00:00:00.000Z"
}
```

`excerpt` is the item text truncated to 280 characters. `sentimentScore` is the per-item compound in `[-1, 1]`. Comments have an empty `title` and `numComments: 0`.

#### `get_feature_requests` — requests and pain points, grouped

Items that voice a feature request, wish, gap, roadmap question, or pain point about the query — grouped by cue category. Input: `query` (required), `channels?`, `windowDays?`, `limit?`.

```jsonc
{
  "query": "prisma",
  "channelsQueried": ["story", "ask_hn", "comment"],
  "windowDays": 30,
  "count": 3,
  "items": [
    {
      "id": "48800042",
      "title": "Ask HN: does Prisma support deep JSON filtering yet?",
      "excerpt": "Please add deep JSON path filters to the query API.",
      "cueCategory": "request",
      "channel": "ask_hn",
      "score": 54,
      "url": "https://news.ycombinator.com/item?id=48800042",
      "createdAt": "2026-06-09T18:30:00.000Z"
    }
  ],
  "byCategory": { "wish": 1, "missing": 1, "request": 1, "plans": 0, "painpoint": 0 },
  "fetchedAt": "2026-07-14T00:00:00.000Z"
}
```

`cueCategory` is one of `request` / `wish` / `missing` / `plans` / `painpoint` (matched by priority in that order). `excerpt` is the matching sentence. `byCategory` totals always sum to `count`.

#### `get_trending_discussions` — highest-engagement stories (no query)

Top Hacker News stories by engagement, no query required. Input: `windowDays?`, `limit?`.

```jsonc
{
  "channelsQueried": ["story"],
  "windowDays": 7,
  "count": 2,
  "items": [
    {
      "id": "48841676",
      "title": "Postgres rewritten in Rust, now passing 100% of the regression tests",
      "channel": "story",
      "score": 980,
      "numComments": 240,
      "engagement": 1220,
      "url": "https://news.ycombinator.com/item?id=48841676",
      "createdAt": "2026-07-12T09:02:00.000Z",
      "sentiment": "Neutral"
    }
  ],
  "fetchedAt": "2026-07-14T00:00:00.000Z"
}
```

`engagement` is `score + numComments`; items are ranked by it descending. Trending is story-level (comments excluded — they have no thread engagement).

### Input

The server boots with **no input required** and returns data immediately — the Hacker News (Algolia) API needs no credentials. All fields below are optional.

| Field | Type | Default | Description |
|---|---|---|---|
| `defaultChannels` | array | `["story","ask_hn","show_hn","comment"]` | HN post types searched when a tool call doesn't specify its own. Allowed: `story`, `ask_hn`, `show_hn`, `comment`. |
| `windowDays` | integer | `30` | Default trailing look-back window in days (1–90). |
| `cacheTtlMinutes` | integer | `20` | How long a query's fetched payload is reused before refetching (1–240). |
| `maxItems` | integer | `100` | Upper bound on items per call; per-call `limit` is clamped to this (10–250). |

### Output

Each tool returns a single structured JSON object (shown above per tool). Responses are deterministic — the same posts plus the same config always produce the same result. Every response includes a `fetchedAt` timestamp reflecting when the underlying Hacker News payload was pulled; a cached read returns the same payload (and timestamp) for that TTL window.

### Data fields reference

| Field | What it tells you |
|---|---|
| `netSentiment` | Mean compound sentiment across matched items, in `[-1, 1]` |
| `sentimentLabel` | Positive / Neutral / Negative, bucketed at ±0.05 |
| `breakdown` | Count of positive / neutral / negative items |
| `mentionVolume` | Number of matched items in the window |
| `topThemes` | Most frequent unigrams/bigrams (stopword- and query-term-filtered) |
| `topSamples` | The three highest-engagement matched items |
| `sentimentScore` | Per-item compound sentiment, in `[-1, 1]` |
| `channel` | HN post type: `story` / `ask_hn` / `show_hn` / `comment` |
| `cueCategory` | Feature-request category: request / wish / missing / plans / painpoint |
| `byCategory` | Count of feature-request items per cue category |
| `engagement` | `score + numComments` for a story (trending rank key) |
| `fetchedAt` | When the underlying Hacker News payload was fetched |

### Pricing

This Actor runs in Standby mode and is billed for the compute used while warm and serving requests. Reads are lightweight — each query's HN data is fetched once, cached (default 20 minutes), and shared across the query tools, so calling several tools for the same query costs a single upstream fetch. There is no LLM in the analysis path, so no per-call model cost, and the Hacker News API is free.

### Tips

- **Start with `get_sentiment_summary`** for the headline, then call a detail tool only when you need it — the query tools share the same cached payload.
- **Narrow `channels`** (e.g. `["ask_hn"]`) to focus on solicitation threads, or drop `comment` to look only at story-level signal.
- **Raise `cacheTtlMinutes`** when batching many queries; lower it when you need fresh reads.
- **Widen `windowDays`** (up to 90) to capture a steadier baseline.

### How it works

1. An MCP client sends a tool call (e.g. `get_sentiment_summary`) with a `query`.
2. The server checks an in-memory LRU + TTL cache. On a miss, it makes one request to the open Hacker News (Algolia) search API across the selected channels and caches the raw items.
3. HN text (which arrives HTML-ish) is stripped of tags and decoded, then pure analysis functions score sentiment (lexicon + negation/intensifier/emoji rules), aggregate it, extract themes, mine feature-request cues, and rank — with no further network calls.
4. The matched window is filtered to the exact day count, and the tool's structured result — aggregates plus raw items plus `fetchedAt` — is returned to the MCP client.

All analysis is deterministic and clock-injected (testable without network). Transient errors (network blips, 5xx) are retried with bounded backoff; rate limits (429) surface a `resetAt` for the caller to handle.

### Works well with

Part of a small slate of agent-focused Apify Actors:

- **[GitHub Repo Intelligence MCP](https://apify.com/joeslade/github-repo-intelligence-mcp)** — opinionated maintainability verdicts for any GitHub repo across five MCP tools.
- **[SERP Topic Gap Monitor](https://apify.com/joeslade/serp-topic-gap-monitor)** — finds topic gaps in search-result coverage and produces scored gap reports.
- **[Docs MCP Server](https://apify.com/joeslade/docs-mcp-server-starter)** — an MCP server giving AI assistants queryable access to framework documentation.

### FAQ and support

**Do I need an API key or account?**
No. The Hacker News (Algolia) search API is open — the Actor boots and returns data with zero setup.

**Is the sentiment from an LLM?**
No. Sentiment is a transparent lexicon-plus-rules scorer (negation, intensifiers, emoji, VADER-style normalization). There is no model in the analysis layer, which is what makes every call deterministic and auditable.

**Does it read comments or just stories?**
Both, by default — HN opinion lives in the comments. Use the `channels` argument to narrow to specific post types.

**Is the output stable?**
Yes. Same items plus same config always yield the same aggregates, and the raw matched items are returned alongside so you can audit every number.

**It returned a rate-limit message — what do I do?**
Hacker News rate limits (429) surface a `resetAt` timestamp; retry after it. Raising `cacheTtlMinutes` reduces upstream calls when batching.

**Found a bug or want a feature?**
Open an issue on the Actor's **Issues** tab. Custom variations are available on request.

### Acknowledgements

The sentiment lexicon is expanded from [VADER](https://github.com/cjhutto/vaderSentiment) (Hutto, C.J. & Gilbert, E.E., 2014), used under its MIT license. Hacker News data via the [Algolia HN Search API](https://hn.algolia.com/api).

### License

Copyright © 2026 Joe Slade.

Licensed under the [GNU Affero General Public License v3.0](LICENSE) (AGPL-3.0). You're free to use, study, modify, and self-host this software; if you run a modified version as a network service, the AGPL requires you to offer your modified source to its users under the same license. For a commercial license not subject to the AGPL's network-copyleft, contact the author.

# Actor input Schema

## `defaultChannels` (type: `array`):

Hacker News post types searched when a tool call does not specify its own. Allowed values: story, ask\_hn, show\_hn, comment. Defaults to all four (stories + comments — HN opinion lives in comments).

## `windowDays` (type: `integer`):

Trailing look-back window (1–90 days) over which mentions are read, when a tool call does not specify its own. Applied as an exact created\_at filter on the Algolia HN API.

## `cacheTtlMinutes` (type: `integer`):

How long a query's fetched Hacker News payload is reused before refetching. Lower = fresher reads; higher = fewer API calls. All query tools share the same cached payload per query.

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

Upper bound on items returned by a single tool call. Per-call 'limit' arguments are clamped to this value.

## Actor input object example

```json
{
  "defaultChannels": [
    "story",
    "ask_hn",
    "show_hn",
    "comment"
  ],
  "windowDays": 30,
  "cacheTtlMinutes": 20,
  "maxItems": 100
}
```

# Actor output Schema

# 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 = {
    "defaultChannels": [
        "story",
        "ask_hn",
        "show_hn",
        "comment"
    ],
    "windowDays": 30,
    "cacheTtlMinutes": 20,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("joeslade/hn-developer-sentiment-mcp").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 = {
    "defaultChannels": [
        "story",
        "ask_hn",
        "show_hn",
        "comment",
    ],
    "windowDays": 30,
    "cacheTtlMinutes": 20,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("joeslade/hn-developer-sentiment-mcp").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 '{
  "defaultChannels": [
    "story",
    "ask_hn",
    "show_hn",
    "comment"
  ],
  "windowDays": 30,
  "cacheTtlMinutes": 20,
  "maxItems": 100
}' |
apify call joeslade/hn-developer-sentiment-mcp --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hacker News Developer Sentiment—What Devs Think (MCP Server)",
        "description": "Zero setup, no API key: a deterministic read on what developers really think of any tool, library, or brand on Hacker News—sentiment, mention volume, themes, and feature requests across HN stories and comments, via 4 agent-callable MCP tools.",
        "version": "0.1",
        "x-build-id": "tJhgNWopIWKASdh15"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/joeslade~hn-developer-sentiment-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-joeslade-hn-developer-sentiment-mcp",
                "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/joeslade~hn-developer-sentiment-mcp/runs": {
            "post": {
                "operationId": "runs-sync-joeslade-hn-developer-sentiment-mcp",
                "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/joeslade~hn-developer-sentiment-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-joeslade-hn-developer-sentiment-mcp",
                "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": {
                    "defaultChannels": {
                        "title": "Default HN channels",
                        "type": "array",
                        "description": "Hacker News post types searched when a tool call does not specify its own. Allowed values: story, ask_hn, show_hn, comment. Defaults to all four (stories + comments — HN opinion lives in comments).",
                        "default": [
                            "story",
                            "ask_hn",
                            "show_hn",
                            "comment"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "windowDays": {
                        "title": "Default window (days)",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Trailing look-back window (1–90 days) over which mentions are read, when a tool call does not specify its own. Applied as an exact created_at filter on the Algolia HN API.",
                        "default": 30
                    },
                    "cacheTtlMinutes": {
                        "title": "Cache TTL (minutes)",
                        "minimum": 1,
                        "maximum": 240,
                        "type": "integer",
                        "description": "How long a query's fetched Hacker News payload is reused before refetching. Lower = fresher reads; higher = fewer API calls. All query tools share the same cached payload per query.",
                        "default": 20
                    },
                    "maxItems": {
                        "title": "Max items per request",
                        "minimum": 10,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Upper bound on items returned by a single tool call. Per-call 'limit' arguments are clamped to this value.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
