# Hacker News Scraper (`constructive_calm/hacker-news-scraper`) Actor

Scrapes Hacker News stories, comments, jobs, polls, and user profiles via the official Firebase and Algolia APIs. Supports full-text search, Who's Hiring thread extraction, author karma snapshots, and deep comment trees.

- **URL**: https://apify.com/constructive\_calm/hacker-news-scraper.md
- **Developed by:** [Omar Eldeeb](https://apify.com/constructive_calm) (community)
- **Categories:** Social media, SEO tools, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.40 / 1,000 data fetcheds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

Scrape **Hacker News** stories, comments, jobs, polls, and user profiles with no proxy, no captcha, no headless browser. Built directly on the official **Firebase** and **Algolia** APIs, so it's fast, reliable, and cheap.

### What does Hacker News Scraper do?

This actor extracts structured data from [Hacker News](https://news.ycombinator.com) — stories, comments, jobs, user profiles, and the monthly **"Ask HN: Who is hiring?"** threads — via HN's two official public APIs (the [Firebase API](https://github.com/HackerNews/API) and the [Algolia search API](https://hn.algolia.com/api)). It produces a unified JSON output with titles, URLs, points, authors, timestamps, and optional full comment trees with author karma snapshots.

Unlike most HN scrapers on the Store that parse HTML and require proxies, this one hits the official APIs directly. You can schedule it, call it via REST/Webhook/MCP from the Apify platform, pipe its output to downstream actors, and never worry about rate limits, captchas, or IP blocks.

### Why use Hacker News Scraper?

- 🏢 **Recruiters & talent teams** — pull the latest "Who is hiring?" monthly thread as structured job rows, filter by role keywords, feed into your ATS.
- 📈 **Market intelligence & PR teams** — monitor mentions of your company, competitors, or product categories with full-text search.
- 🧠 **AI/LLM data pipelines** — build clean, deduplicated training or retrieval-augmented-generation datasets from HN discussions, with author karma signals.
- 📰 **Newsletters & aggregators** — daily digest of top / new / best stories above a score threshold, optionally filtered to specific domains.
- 🎯 **Research & academia** — reproducible HN corpora for discourse analysis, link-graph research, or longitudinal studies of tech discussion.

### How to use Hacker News Scraper

1. Click **Try for free** on this actor's page to open the Apify Console input form.
2. Pick a **mode** — start with `topstories` to see how it works.
3. Set **Max items** (default 30). For a first run, try 10.
4. Click **Save & Start**.
5. When the run finishes, open the **Output** tab to see the scraped items, or use **Export** to download as JSON, CSV, or Excel.
6. For more advanced runs, enable **Include comments** to attach comment trees, or use `mode=search` to run a keyword query.

### Input

Every field is configurable via the input form. See the **Input** tab for live validation and tooltips. The only required field is `mode`.

Minimal examples (copy into the Console's "JSON" tab):

**Top 30 front-page stories:**
```json
{ "mode": "topstories", "maxItems": 30 }
````

**Stories mentioning "Claude", newest first, ≥ 50 points:**

```json
{
    "mode": "search",
    "searchQuery": "Claude",
    "sortSearchBy": "date",
    "minScore": 50,
    "maxItems": 100
}
```

**Show HN from `github.com` or `arxiv.org` with heavy discussion:**

```json
{
    "mode": "showstories",
    "minScore": 50,
    "minComments": 20,
    "domainFilter": ["github.com", "arxiv.org"],
    "maxItems": 50
}
```

**Latest "Who is hiring?" thread as structured job rows:**

```json
{ "mode": "hiring_threads", "maxItems": 500 }
```

**A story + its full 3-level comment tree + author karma:**

```json
{
    "mode": "topstories",
    "maxItems": 5,
    "includeComments": true,
    "maxCommentDepth": 3,
    "includeUserProfiles": true
}
```

### Output

Every row — whether it's a story, comment, job, or poll — uses the same unified shape. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
    "id": 47822805,
    "type": "story",
    "title": "SPEAKE(a)R: Turn Speakers to Microphones for Fun and Profit",
    "url": "https://www.usenix.org/system/files/conference/woot17/woot17-paper-guri.pdf",
    "domain": "usenix.org",
    "hnUrl": "https://news.ycombinator.com/item?id=47822805",
    "by": "Eridanus2",
    "byUserKarma": 1847,
    "byUserCreated": 1625097600,
    "score": 67,
    "time": 1776588348,
    "createdAt": "2026-04-19T08:45:48.000Z",
    "descendants": 26,
    "comments": [
        {
            "id": 47823010,
            "by": "someuser",
            "text": "<p>Interesting approach...</p>",
            "depth": 1,
            "replies": [{ "id": 47823201, "by": "replyer", "text": "...", "depth": 2 }]
        }
    ],
    "scrapedAt": "2026-04-19T11:21:58.601Z",
    "source": "firebase"
}
```

#### Data fields

| Field | Type | Description |
|---|---|---|
| `id` | number | Unique HN item ID |
| `type` | enum | `story` / `comment` / `job` / `poll` / `pollopt` |
| `title` | string | Story / job title (null for comments) |
| `url` | string | Outbound URL for stories (null for text-only) |
| `domain` | string | Extracted hostname (e.g., `github.com`) |
| `hnUrl` | string | Deep link to the item on news.ycombinator.com |
| `by` | string | Author username |
| `byUserKarma` | number | Author's karma (when `includeUserProfiles=true`) |
| `byUserCreated` | number | Unix timestamp of author account creation |
| `score` | number | Points (votes) |
| `time` | number | Unix timestamp of submission |
| `createdAt` | string | ISO 8601 timestamp |
| `text` | string | HTML body (comments, Ask HN, job descriptions) |
| `descendants` | number | Total comments on a story |
| `parent` | number | Parent ID for comments |
| `comments` | array | Nested comment tree (when `includeComments=true`) |
| `flatComments` | array | Flat list with depth (when `flattenComments=true`) |
| `deleted` / `dead` | boolean | Item status flags |
| `scrapedAt` | string | ISO timestamp when this row was fetched |
| `source` | enum | `firebase` or `algolia` — which API returned it |

### How much does it cost to scrape Hacker News?

This actor uses **pay-per-event** pricing — you only pay for the rows you get, no monthly subscription.

| Event | Price |
|---|---|
| `story-fetched` | $0.00040 / item ($0.40 per 1,000 stories or jobs) |
| `comment-fetched` | $0.00015 / comment ($0.15 per 1,000 comments) |
| `user-profile-fetched` | $0.00030 / profile ($0.30 per 1,000 profiles — only when `includeUserProfiles=true`) |

**The first 50 chargeable events in every run are free.** That means any run with ≤ 50 total output rows + comments + profiles costs nothing beyond the platform's trivial startup fee. You only pay for events 51+ within the same run.

Typical run costs (after the 50-event trial is exhausted in the same run):

- 100 top stories (no comments): 100 stories → 50 free + 50 paid = **$0.020**
- 30 top stories + ~10 comments each (≈ 330 events): **~$0.046**
- Monthly "Who is hiring?" full extract (≈ 500 jobs): **$0.180**
- 1,000 search hits on a keyword: **$0.380**
- A 30-story smoke test with no comments: **$0 (entirely free)**

### Tips & advanced options

- **Comment depth** — `maxCommentDepth=3` is a good default. 5+ is only useful for megathreads; 1 gives you only top-level replies.
- **Domain filter** — combine with `topstories` or `showstories` for a recruiter-style feed of GitHub / Arxiv / company-blog stories.
- **Date ranges** — pass `dateFromUnix` / `dateToUnix` (Unix seconds) to scope search mode. Works best with `sortSearchBy=date`.
- **User karma snapshot** — `includeUserProfiles=true` adds `byUserKarma` + `byUserCreated` to every row. Useful for weighting by poster reputation.
- **Flatten comments for spreadsheets** — set `flattenComments=true` to get a flat array with a `depth` field, which exports cleanly to CSV/Excel.
- **Schedule it** — use Apify's scheduler to run `topstories` every hour for a live HN feed, or `hiring_threads` monthly.
- **Chain it** — pipe the output into another actor (e.g., a text classifier, Slack poster) via Apify's integrations.

### FAQ, disclaimers & support

**Does this need a proxy?** No. Both HN APIs are public and unmetered.

**How fresh is the data?** Firebase list endpoints update roughly every 5 minutes (HN's own cadence). `user` and `hiring_threads` are live.

**What counts as a "comment" for billing?** Only comments that actually appear in your output dataset — i.e. inside the depth limit you set. Comments skipped because they're deleted or beyond `maxCommentDepth` are free.

**Can I search for comments by a specific author?** Yes — set `mode=search` with `searchTags: ["comment", "author_dang"]`.

**Why are some `by` fields null?** Deleted items have no author. They're filtered out by default.

**Legality.** Hacker News data is publicly accessible and both APIs are officially sanctioned by Y Combinator. This actor respects those APIs' rate limits and does not bypass any access control. You are responsible for compliant use of the data under Y Combinator's [Terms of Service](https://www.ycombinator.com/legal/) and any applicable privacy laws (GDPR, CCPA, etc.) when processing personal data such as usernames.

**Found a bug or want a feature?** Open an issue on the actor's Issues tab. Custom extensions (e.g., Slack / Discord forwarding, semantic dedupe, dashboards) are available on request.

# Actor input Schema

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

What to scrape. 'topstories' / 'newstories' / 'beststories' pull from the official Firebase lists. 'askstories' / 'showstories' / 'jobstories' return only Ask HN / Show HN / jobs. 'search' runs a full-text Algolia query. 'user' returns everything a username has submitted. 'hiring\_threads' auto-detects the latest monthly 'Ask HN: Who is hiring?' post and returns its top-level job comments.

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

Maximum number of top-level items to return (stories for list/search/user modes, comments for hiring mode). Firebase list endpoints cap at 500; Algolia search caps at 1000 per page but can paginate further.

## `includeComments` (type: `boolean`):

If enabled, each story's full comment tree is fetched and attached under the `comments` field (respecting `maxCommentDepth`). Adds latency and per-comment billing.

## `maxCommentDepth` (type: `integer`):

Maximum nesting depth when expanding comment trees. 1 = top-level replies only, 10 = deepest practical threads. Ignored when `includeComments` is off.

## `flattenComments` (type: `boolean`):

If enabled, comments are returned as a flat array (with a `depth` field) instead of a nested tree. Useful for spreadsheet-friendly output.

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

Skip stories with fewer points than this. 0 = no filter. Example: set to 100 to only get front-page-worthy stories.

## `minComments` (type: `integer`):

Skip stories with fewer comments (descendants) than this. 0 = no filter. Useful for filtering to heavily-discussed threads.

## `dateFromUnix` (type: `integer`):

Only return items created after this Unix timestamp (seconds since epoch). Leave empty for no lower bound. Example: 1735689600 = 2025-01-01.

## `dateToUnix` (type: `integer`):

Only return items created before this Unix timestamp (seconds since epoch). Leave empty for no upper bound.

## `domainFilter` (type: `array`):

If set, only stories whose URL domain matches one of these are returned. Example: \["github.com", "arxiv.org"] for tech-focused scraping.

## `searchQuery` (type: `string`):

Full-text search query. Required when `mode` is 'search'. Example: "Claude" or "GPT-5 launch".

## `searchTags` (type: `array`):

Restrict search results by type. Options: 'story', 'comment', 'poll', 'job'. You can also pass 'author\_<username>' or 'story\_<id>' (advanced). Ignored outside search mode.

## `sortSearchBy` (type: `string`):

Sort Algolia search results by relevance (best match first) or by date (newest first).

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

HN username whose submissions to fetch. Required when `mode` is 'user'. Case-sensitive. Example: "dang".

## `includeUserProfiles` (type: `boolean`):

If enabled, each story (and comment, if `includeComments` is on) is enriched with the author's karma and account age. Adds one API call per unique author and is billed separately.

## Actor input object example

```json
{
  "mode": "topstories",
  "maxItems": 30,
  "includeComments": false,
  "maxCommentDepth": 3,
  "flattenComments": false,
  "minScore": 0,
  "minComments": 0,
  "domainFilter": [],
  "searchQuery": "Claude",
  "searchTags": [],
  "sortSearchBy": "relevance",
  "username": "dang",
  "includeUserProfiles": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset of HN stories, comments, jobs, and polls with scores, timestamps, author metadata, and optional nested comment trees.

# 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 = {
    "maxItems": 30,
    "searchQuery": "Claude",
    "username": "dang"
};

// Run the Actor and wait for it to finish
const run = await client.actor("constructive_calm/hacker-news-scraper").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 = {
    "maxItems": 30,
    "searchQuery": "Claude",
    "username": "dang",
}

# Run the Actor and wait for it to finish
run = client.actor("constructive_calm/hacker-news-scraper").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 '{
  "maxItems": 30,
  "searchQuery": "Claude",
  "username": "dang"
}' |
apify call constructive_calm/hacker-news-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hacker News Scraper",
        "description": "Scrapes Hacker News stories, comments, jobs, polls, and user profiles via the official Firebase and Algolia APIs. Supports full-text search, Who's Hiring thread extraction, author karma snapshots, and deep comment trees.",
        "version": "1.0",
        "x-build-id": "pRvFdTfxPQRT0wKrZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/constructive_calm~hacker-news-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-constructive_calm-hacker-news-scraper",
                "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/constructive_calm~hacker-news-scraper/runs": {
            "post": {
                "operationId": "runs-sync-constructive_calm-hacker-news-scraper",
                "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/constructive_calm~hacker-news-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-constructive_calm-hacker-news-scraper",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Scraping mode",
                        "enum": [
                            "topstories",
                            "newstories",
                            "beststories",
                            "askstories",
                            "showstories",
                            "jobstories",
                            "search",
                            "user",
                            "hiring_threads"
                        ],
                        "type": "string",
                        "description": "What to scrape. 'topstories' / 'newstories' / 'beststories' pull from the official Firebase lists. 'askstories' / 'showstories' / 'jobstories' return only Ask HN / Show HN / jobs. 'search' runs a full-text Algolia query. 'user' returns everything a username has submitted. 'hiring_threads' auto-detects the latest monthly 'Ask HN: Who is hiring?' post and returns its top-level job comments.",
                        "default": "topstories"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of top-level items to return (stories for list/search/user modes, comments for hiring mode). Firebase list endpoints cap at 500; Algolia search caps at 1000 per page but can paginate further.",
                        "default": 30
                    },
                    "includeComments": {
                        "title": "Include comments",
                        "type": "boolean",
                        "description": "If enabled, each story's full comment tree is fetched and attached under the `comments` field (respecting `maxCommentDepth`). Adds latency and per-comment billing.",
                        "default": false
                    },
                    "maxCommentDepth": {
                        "title": "Max comment depth",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum nesting depth when expanding comment trees. 1 = top-level replies only, 10 = deepest practical threads. Ignored when `includeComments` is off.",
                        "default": 3
                    },
                    "flattenComments": {
                        "title": "Flatten comments",
                        "type": "boolean",
                        "description": "If enabled, comments are returned as a flat array (with a `depth` field) instead of a nested tree. Useful for spreadsheet-friendly output.",
                        "default": false
                    },
                    "minScore": {
                        "title": "Minimum score",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip stories with fewer points than this. 0 = no filter. Example: set to 100 to only get front-page-worthy stories.",
                        "default": 0
                    },
                    "minComments": {
                        "title": "Minimum comments",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip stories with fewer comments (descendants) than this. 0 = no filter. Useful for filtering to heavily-discussed threads.",
                        "default": 0
                    },
                    "dateFromUnix": {
                        "title": "Date from (Unix timestamp)",
                        "type": "integer",
                        "description": "Only return items created after this Unix timestamp (seconds since epoch). Leave empty for no lower bound. Example: 1735689600 = 2025-01-01."
                    },
                    "dateToUnix": {
                        "title": "Date to (Unix timestamp)",
                        "type": "integer",
                        "description": "Only return items created before this Unix timestamp (seconds since epoch). Leave empty for no upper bound."
                    },
                    "domainFilter": {
                        "title": "Domain filter",
                        "type": "array",
                        "description": "If set, only stories whose URL domain matches one of these are returned. Example: [\"github.com\", \"arxiv.org\"] for tech-focused scraping.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search query (Algolia)",
                        "type": "string",
                        "description": "Full-text search query. Required when `mode` is 'search'. Example: \"Claude\" or \"GPT-5 launch\".",
                        "default": ""
                    },
                    "searchTags": {
                        "title": "Search tags (Algolia)",
                        "type": "array",
                        "description": "Restrict search results by type. Options: 'story', 'comment', 'poll', 'job'. You can also pass 'author_<username>' or 'story_<id>' (advanced). Ignored outside search mode.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortSearchBy": {
                        "title": "Sort search results",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Sort Algolia search results by relevance (best match first) or by date (newest first).",
                        "default": "relevance"
                    },
                    "username": {
                        "title": "Username",
                        "type": "string",
                        "description": "HN username whose submissions to fetch. Required when `mode` is 'user'. Case-sensitive. Example: \"dang\".",
                        "default": ""
                    },
                    "includeUserProfiles": {
                        "title": "Include user profiles",
                        "type": "boolean",
                        "description": "If enabled, each story (and comment, if `includeComments` is on) is enriched with the author's karma and account age. Adds one API call per unique author and is billed separately.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```