# Hacker News MCP Server (`automation-lab/hackernews-mcp-server`) Actor

Query Hacker News data programmatically: search stories, get top posts, Ask HN, Show HN, jobs, comments, and user profiles via the free HN Algolia API.

- **URL**: https://apify.com/automation-lab/hackernews-mcp-server.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Hacker News MCP Server

Query **Hacker News** programmatically using the free [HN Algolia API](https://hn.algolia.com/api). Search stories, fetch top/front-page posts, Ask HN threads, Show HN projects, job listings, story comments, and user profiles — all without scraping, without a browser, and without an API key.

Designed as an **MCP-first actor**: AI agents and LLM workflows can call it as a tool. Human users can run it directly on Apify with a simple JSON input.

### What does the Hacker News MCP Server do?

🔧 It exposes 7 tools wrapping the HN Algolia API:

| Tool | What it returns |
|------|----------------|
| `search_stories` | Full-text search across all HN stories with optional date range |
| `get_top_stories` | Current front-page/trending stories |
| `get_ask_hn` | Recent Ask HN threads |
| `get_show_hn` | Recent Show HN posts |
| `get_jobs` | Latest HN job listings |
| `get_story_comments` | Full comment tree for any story |
| `get_user_profile` | User karma, bio, and account info |

No proxy is needed — the Algolia API is public and free. Each run typically completes in under 3 seconds.

### Who is this for?

**AI agent developers** building research pipelines that need live HN data. Feed trending stories into your LLM workflow, extract what tech topics are trending today, or pull discussion threads for analysis — all via a single tool call.

**Researchers and analysts** tracking tech discourse. Pull Ask HN threads on a topic, compare what developers are discussing week over week, or find everyone who worked on a project from Show HN.

**Recruiters and job seekers** monitoring HN hiring. The `get_jobs` tool pulls the latest "Who is Hiring?" thread posts and HN Startups listings without any browser automation.

**Developers building with Apify** who want a reliable, cost-predictable HN data source with structured JSON output, scheduling, and webhook support.

### Why use Hacker News MCP Server?

- ✅ **No API key or login required** — wraps the free public HN Algolia API
- ✅ **7 distinct tools in one actor** — search, browse, comments, and users, all from one place
- ✅ **MCP-native design** — call individual tools from Claude, Cursor, or any MCP client
- ✅ **Structured JSON output** — consistent field names across all tools, ready for downstream processing
- ✅ **Date range filtering** — search stories within specific time windows
- ✅ **HTTP-only, no browser** — fast, cheap, and reliable (256 MB, ~2s average runtime)
- ✅ **No scraping** — uses the official Algolia search index, so no anti-bot risk

### What data can you extract?

**Stories (all story tools)**
| Field | Description |
|-------|-------------|
| `objectID` | HN item ID |
| `title` | Story title |
| `url` | Link URL (external article or HN thread) |
| `author` | HN username |
| `points` | Upvotes |
| `num_comments` | Comment count |
| `created_at` | ISO 8601 timestamp |
| `text` | Story body text (Ask HN / Show HN) |
| `tags` | Algolia tags (`story`, `ask_hn`, `show_hn`, `job`, etc.) |

**Comments (`get_story_comments`)**
| Field | Description |
|-------|-------------|
| `type` | `comment` |
| `text` | Comment body (may include HTML tags) |
| `parent_id` | ID of parent comment or story |
| `story_id` | Root story ID |
| `author` | Commenter username |
| `created_at` | Timestamp |

**Users (`get_user_profile`)**
| Field | Description |
|-------|-------------|
| `karma` | Karma points |
| `about` | Bio/about text |
| `created_at` | Account creation date |
| `submission_count` | Number of submissions |
| `comment_count` | Number of comments |

### How much does it cost to query Hacker News data?

This actor uses **pay-per-event (PPE) pricing**:

| Event | Free tier | Paid tiers |
|-------|-----------|-----------|
| Run start (one-time) | $0.005 | $0.0025–$0.005 |
| Tool invocation | $0.002 | $0.0008–$0.002 |

**Real-world cost examples:**
- Search for 20 stories: **~$0.007** total
- Fetch front-page stories (20 results): **~$0.007**
- Pull 100 comments from a story: **~$0.007** (one tool call)
- Run 100 searches per day: **~$0.70/day**

With the free **$5 credit** on Apify's Free plan, you can run approximately **700 tool invocations** — enough to prototype any HN data workflow.

### How to query Hacker News data

1. Go to [Hacker News MCP Server on Apify Store](https://apify.com/automation-lab/hackernews-mcp-server)
2. Click **Try for free**
3. Set the **Tool** dropdown to your desired action (e.g., `search_stories`)
4. Fill in the relevant parameters (e.g., `query: "Rust programming"`)
5. Click **Start** and wait 2–5 seconds
6. View results in the **Dataset** tab as structured JSON

**Example inputs for each tool:**

```json
// Search recent stories about AI
{
  "tool": "search_stories",
  "query": "LLM inference",
  "maxResults": 20,
  "sortBy": "date",
  "dateFrom": "2025-01-01T00:00:00Z"
}
````

```json
// Get today's top HN stories
{
  "tool": "get_top_stories",
  "maxResults": 30
}
```

```json
// Pull comments from a specific story
{
  "tool": "get_story_comments",
  "storyId": 39234738,
  "maxResults": 50
}
```

```json
// Look up a user profile
{
  "tool": "get_user_profile",
  "username": "pg"
}
```

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `tool` | string | ✅ Yes | — | Tool to invoke (see 7 tool names above) |
| `query` | string | For `search_stories` | — | Search keyword or phrase |
| `dateFrom` | string | No | — | ISO 8601 start date for `search_stories` filter |
| `dateTo` | string | No | — | ISO 8601 end date for `search_stories` filter |
| `storyId` | integer | For `get_story_comments` | — | HN story ID (numeric, from the item URL) |
| `username` | string | For `get_user_profile` | — | HN username |
| `maxResults` | integer | No | 20 | Max results to return (1–100) |
| `sortBy` | string | No | `relevance` | Sort order: `relevance` or `date` |

### Output examples

**`search_stories` / `get_top_stories` output item:**

```json
{
  "type": "story",
  "objectID": "46990729",
  "title": "An AI agent published a hit piece on me",
  "url": "https://theshamblog.com/an-ai-agent-published-a-hit-piece-on-me/",
  "author": "scottshambaugh",
  "points": 2346,
  "num_comments": 951,
  "created_at": "2026-02-12T16:23:24Z",
  "text": null,
  "tags": ["story", "front_page"]
}
```

**`get_story_comments` output item:**

```json
{
  "type": "comment",
  "objectID": "47679234",
  "author": "throweraway",
  "text": "This is exactly why we need better tooling for...",
  "created_at": "2026-04-07T19:12:00.000Z",
  "parent_id": 47679121,
  "story_id": 47679121
}
```

**`get_user_profile` output item:**

```json
{
  "type": "user",
  "objectID": "pg",
  "author": "pg",
  "karma": 157316,
  "about": "Bug fixer.",
  "created_at": "2006-10-09T18:21:51Z"
}
```

### Tips for best results

- 💡 **Use `sortBy: "date"` with `dateFrom`** for real-time monitoring (e.g., past 24 hours)
- 💡 **Keep `maxResults` ≤ 20** for fast runs; increase to 100 only when you need volume
- 💡 **For `get_story_comments`**: very large threads (500+ comments) return up to `maxResults` comments from the top of the tree — the API uses BFS ordering
- 💡 **Story IDs** appear in HN URLs: `https://news.ycombinator.com/item?id=39234738` → `storyId: 39234738`
- 💡 **Schedule daily** with `get_top_stories` to build a trending-story feed
- 💡 **Combine tools**: first call `search_stories` to find a story ID, then `get_story_comments` to pull the discussion

### Integrations

**HN stories → Google Sheets** — schedule `get_top_stories` daily, connect the dataset via Apify's Google Sheets integration to track which stories went viral. Use the built-in dataset export (JSON, CSV, Excel).

**HN jobs → Slack** — run `get_jobs` on a schedule, use Apify webhooks to post new listings to a `#hiring` Slack channel. Never miss a relevant startup job post.

**HN search → Make/Zapier** — trigger a `search_stories` run whenever a topic keyword appears, and route results to Notion, Airtable, or a CRM. Useful for competitive monitoring (track mentions of your product or competitors).

**AI research pipeline** — chain this actor with an LLM summarizer: pull Ask HN threads on a topic, send them to Claude/GPT for summarization, and generate a weekly digest. The structured JSON output maps cleanly to LLM context windows.

**Webhooks** — configure Apify webhooks on run completion to stream new HN data to your backend in real time.

### Using the Apify API

**Node.js (Apify client)**

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('automation-lab/hackernews-mcp-server').call({
  tool: 'search_stories',
  query: 'TypeScript 5.0',
  maxResults: 20,
  sortBy: 'date',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("automation-lab/hackernews-mcp-server").call(run_input={
    "tool": "get_ask_hn",
    "maxResults": 10,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["points"])
```

**cURL**

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~hackernews-mcp-server/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "tool": "get_show_hn",
    "maxResults": 20
  }'
```

### Use with AI agents via MCP

Hacker News MCP Server is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/hackernews-mcp-server"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/hackernews-mcp-server"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/hackernews-mcp-server to search for HN stories about Rust programming from the last 30 days, sorted by date"
- "Get the current top 20 stories from Hacker News front page and summarize the main themes"
- "Pull the comments from HN story 47679121 and find the most upvoted technical critiques"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Is it legal to query Hacker News data?

Yes. This actor uses the **official HN Algolia API** (`https://hn.algolia.com/api/v1/`) which is a public, free, rate-limit-free API provided explicitly for programmatic access to Hacker News data. There is no scraping involved.

Hacker News content is user-submitted and governed by [Y Combinator's terms of service](https://www.ycombinator.com/legal/). Respect the API's fair-use spirit: don't hammer it with thousands of requests per second, and attribute content to original authors when appropriate.

This actor does not bypass any authentication, rate limiting, or access controls.

### FAQ

**How fast is it?**
Most runs complete in 1–3 seconds. The HN Algolia API is fast and globally distributed. The actor uses Node.js `fetch()` with no browser overhead.

**How much does it cost for 100 searches?**
About $0.70 ($0.005 start + $0.002 × 100 tool calls). With Apify's free $5 credit you can run roughly 700 tool invocations before needing a paid plan.

**How is this different from the official HN Firebase API?**
The official [HN Firebase API](https://github.com/HackerNews/API) requires fetching each item individually and has no search. The Algolia API (used here) supports full-text search, tag filtering, date range queries, and returns full hit lists in a single request. Much more practical for programmatic use.

**Why do some stories have no `url` field?**
Ask HN and some Show HN posts are self-posts (text only). For these, the URL points back to the HN thread itself. The `text` field contains the body.

**Why did `get_story_comments` return only 1 item?**
The story may be very old (pre-2012) or have been indexed without its comment tree by Algolia. The actor returns the story itself plus all comments it could retrieve. For older stories, the Algolia `/items/{id}` endpoint may have no `children` array.

**The search returned fewer results than `maxResults`. Why?**
The HN Algolia index may have fewer matching results than your limit, or the story was submitted very recently and not yet indexed. Try again in a few minutes for very fresh content.

### Other developer tools you might like

- 🔗 [Bing Search Scraper](https://apify.com/automation-lab/bing-search-scraper) — scrape Bing web search results for any query
- 🔗 [Bing News Scraper](https://apify.com/automation-lab/bing-news-scraper) — track news coverage on any topic
- 🔗 [arXiv Scraper](https://apify.com/automation-lab/arxiv-scraper) — search and extract research papers from arXiv
- 🔗 [JSON Schema Generator](https://apify.com/automation-lab/json-schema-generator) — generate JSON schemas from sample data
- 🔗 [AI Tools Directory Scraper](https://apify.com/automation-lab/ai-tools-directory-scraper) — discover new AI tools and products

# Actor input Schema

## `tool` (type: `string`):

Which HN tool to invoke. Options: search\_stories, get\_top\_stories, get\_ask\_hn, get\_show\_hn, get\_jobs, get\_story\_comments, get\_user\_profile.

## `query` (type: `string`):

Search term for search\_stories tool. E.g. 'TypeScript', 'AI agent', 'startup'.

## `dateFrom` (type: `string`):

Filter stories created after this date. ISO 8601 format, e.g. 2024-01-01T00:00:00Z.

## `dateTo` (type: `string`):

Filter stories created before this date. ISO 8601 format.

## `storyId` (type: `integer`):

HN story ID for get\_story\_comments tool. E.g. 39234738.

## `username` (type: `string`):

HN username for get\_user\_profile tool. E.g. 'pg', 'dang'.

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

Maximum number of results to return (1–100). Default: 20.

## `sortBy` (type: `string`):

Sort order for search results. 'relevance' (default for search) or 'date' (newest first).

## Actor input object example

```json
{
  "tool": "search_stories",
  "query": "AI agents",
  "maxResults": 20,
  "sortBy": "relevance"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "tool": "search_stories",
    "query": "AI agents"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/hackernews-mcp-server").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 = {
    "tool": "search_stories",
    "query": "AI agents",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/hackernews-mcp-server").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 '{
  "tool": "search_stories",
  "query": "AI agents"
}' |
apify call automation-lab/hackernews-mcp-server --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hacker News MCP Server",
        "description": "Query Hacker News data programmatically: search stories, get top posts, Ask HN, Show HN, jobs, comments, and user profiles via the free HN Algolia API.",
        "version": "0.1",
        "x-build-id": "Wdk1FEFWAEAAihH25"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~hackernews-mcp-server/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-hackernews-mcp-server",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~hackernews-mcp-server/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-hackernews-mcp-server",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~hackernews-mcp-server/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-hackernews-mcp-server",
                "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": [
                    "tool"
                ],
                "properties": {
                    "tool": {
                        "title": "🔧 Tool to call",
                        "enum": [
                            "search_stories",
                            "get_top_stories",
                            "get_ask_hn",
                            "get_show_hn",
                            "get_jobs",
                            "get_story_comments",
                            "get_user_profile"
                        ],
                        "type": "string",
                        "description": "Which HN tool to invoke. Options: search_stories, get_top_stories, get_ask_hn, get_show_hn, get_jobs, get_story_comments, get_user_profile."
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Search term for search_stories tool. E.g. 'TypeScript', 'AI agent', 'startup'."
                    },
                    "dateFrom": {
                        "title": "Date from (ISO 8601)",
                        "type": "string",
                        "description": "Filter stories created after this date. ISO 8601 format, e.g. 2024-01-01T00:00:00Z."
                    },
                    "dateTo": {
                        "title": "Date to (ISO 8601)",
                        "type": "string",
                        "description": "Filter stories created before this date. ISO 8601 format."
                    },
                    "storyId": {
                        "title": "Story ID",
                        "type": "integer",
                        "description": "HN story ID for get_story_comments tool. E.g. 39234738."
                    },
                    "username": {
                        "title": "Username",
                        "type": "string",
                        "description": "HN username for get_user_profile tool. E.g. 'pg', 'dang'."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of results to return (1–100). Default: 20.",
                        "default": 20
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Sort order for search results. 'relevance' (default for search) or 'date' (newest first).",
                        "default": "relevance"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
