# NIH RePORTER Award Monitor (`bytehavenstudios/nih-reporter-award-monitor`) Actor

First-seen and change-detection over the live NIH RePORTER research-award feed. Polls the v2 projects API and normalizes each award to one flat record (IDs, title, PI, organization, fiscal year, amount, funding IC, dates, abstract), emitting new awards plus re-emits on changes. Keyless.

- **URL**: https://apify.com/bytehavenstudios/nih-reporter-award-monitor.md
- **Developed by:** [ByteHaven Studios](https://apify.com/bytehavenstudios) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 project returneds

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

## NIH RePORTER Award Monitor

**First-seen + change-detection over the live NIH RePORTER research-award feed.** NIH RePORTER is the
U.S. government's authoritative record of the grants, contracts, and cooperative agreements the National
Institutes of Health funds — who got funded, by which Institute/Center, for how much, on what topic.
Farms republish the normalized award record as a static snapshot; nobody sells the **delta**. This
Actor polls the v2 `/v2/projects/search` query API with a JSON `criteria` body, pages through
`meta.total` (500 per page, capped at the 15,000-record search ceiling), snapshots a per-award
fingerprint in the key-value store, and emits one record per **newly-seen** award **plus a re-emit
whenever a watched award changes** — an `award_amount` revision (administrative supplement), a
`project_end_date` extension (no-cost extension), or a later-added abstract / terms list. A snapshot of
the whole portfolio becomes an operational "what got funded — or re-funded — in my field, since I last
looked" alert stream.

Plain HTTPS calls to one clean REST/JSON host — no browser, no proxy, no login, **no API key** (the
RePORTER API is keyless and public-domain). The documented rate limit is 1 request/second; the fetch
layer paces to it. **Data source: NIH RePORTER, U.S. government public domain (Title 17 U.S.C.).**

> Data courtesy of the NIH RePORTER API (U.S. National Institutes of Health).

> **Status: launch-ready (v0.1, unpublished by design).** All layers are implemented and tested
> offline — the fetch/paginate/normalize layer (`src/nih.js`), the fingerprint diff (`src/diff.js`),
> the client filters (`src/filters.js`), the Actor entry (`src/main.js`), the unit + integration suites
> (`test/`), the compliance record (`COMPLIANCE.md`), and the pricing/listing drafts (`docs/`). This
> Actor is **built, never published** — no `apify push`, no on-platform pricing. See `CHANGELOG.md` for
> the slice history.

---

### What it does

Each run resolves an `award_notice_date` delta window, builds the v2 search `criteria` body, and pages
the `/v2/projects/search` query API (`limit` up to 500, `offset` until `meta.total` is exhausted or the
15,000-record ceiling is hit) under a 1 req/s token bucket with exponential backoff on 429/5xx. Each
award is normalized to one flat `award` shape — application id, project + core project number, title,
contact PI + investigators, organization, fiscal year, award amount, funding IC, project dates,
abstract/terms — then diffed against the prior run's per-award fingerprint map to emit only what is new
or changed.

- **The delta, not the blob** (the moat): NIH awards mutate after the notice — supplements revise the
  amount, no-cost extensions move the end date, abstracts land late. This emits exactly those
  transitions over a corpus everyone else republishes whole.
- **Award identity done right**: the diff keys on `appl_id` (the unique application id), so each award
  year is its own record and a supplement's amount revision is a first-class `changed` event —
  `core_project_num` groups an award's support years for the reader.
- **Server-side + client filters**: `advanced_text_search`, `org_names`, `pi_names`, `agencies`,
  `fiscal_years`, `award_amount_range` narrow the query at the API; text / IC / award-floor criteria are
  re-applied client-side as a belt-and-suspenders pass.
- **Change monitor**: `monitorNewOnly` persists the fingerprint map + the award-notice high-water-mark
  and, on the next scheduled run, emits only newly-seen or changed awards. A first run seeds the
  baseline (emits nothing).

### Inputs

| Input | Type | Notes |
|---|---|---|
| `textSearch` | string | RePORTER `advanced_text_search` over title/abstract/terms. Empty = all |
| `orgNames` | array | Grantee organization names (`org_names`, contains-match). Empty = all |
| `piNames` | array | PI names (`pi_names` any-name match). Empty = all |
| `fundingIc` | array | NIH IC / agency abbreviations (`agencies`, e.g. NCI, NIAID). Empty = all |
| `fiscalYears` | array | Fiscal years (`fiscal_years`, e.g. 2026). Empty = all in the window |
| `awardAmountMin` | integer | Minimum total award amount (`award_amount_range.min_amount`). 0 = no floor |
| `since` | string | Lower bound of the `award_notice_date` window (YYYY-MM-DD). Empty = recent trailing window |
| `until` | string | Optional upper bound (`award_notice_date.to_date`). Empty = now |
| `monitorNewOnly` | boolean | Diff vs the stored fingerprint map; emit only new/changed. Default: on |
| `maxResults` | integer | Cap total records returned (0 = no cap) |
| `proxyConfiguration` | object | Optional; the API is open and needs no proxy. Default: none |

### Output — one record per new / changed award

```json
{
  "applId": 10812345,
  "projectNum": "5R01CA123456-04",
  "coreProjectNum": "R01CA123456",
  "title": "Mechanisms of Tumor Immune Evasion",
  "contactPi": "DOE, JANE",
  "investigators": ["DOE, JANE", "SMITH, JOHN"],
  "organization": "STANFORD UNIVERSITY",
  "fiscalYear": 2026,
  "awardAmount": 512340,
  "fundingIc": "NCI",
  "projectStartDate": "2023-04-01",
  "projectEndDate": "2027-03-31",
  "awardNoticeDate": "2026-04-15",
  "abstract": "This project investigates the mechanisms by which tumors evade immune surveillance...",
  "terms": ["Immunology", "Oncology", "T-Lymphocytes"],
  "detailUrl": "https://reporter.nih.gov/project-details/10812345",
  "changeType": "changed",
  "changedFields": ["awardAmount", "projectEndDate"],
  "attribution": "Data courtesy of the NIH RePORTER API (U.S. National Institutes of Health).",
  "fetchedAt": "2026-07-10T14:00:00.000Z"
}
````

`applId` (the unique application id) is the dedupe key. `changeType` is `new` (first-seen) or `changed`
under `monitorNewOnly`, or `listed` in plain full-window mode (`monitorNewOnly: false`, no diff);
`changedFields` lists the fingerprint fields that moved (empty for `new`/`listed`). An award whose abstract has
not posted yet has `abstract` `null`, and the later `null → present` transition is a reported change.
Every record carries the courtesy `attribution` string.

#### Control records (not charged)

Three non-award records may be pushed to signal run state. None triggers a `project-returned` charge:

| Record | When | Shape |
|---|---|---|
| `_baseline` | First run (empty prior state): the fingerprint map is snapshotted as the baseline and no change events are emitted | `{ "_baseline": true, "filters": {...}, "snapshotSize": N, "window": {...}, "message": "...", "fetchedAt": "..." }` |
| `_noData` | A subsequent run whose delta is empty (no new/changed awards matched the filters) | `{ "_noData": true, "filters": {...}, "message": "...", "fetchedAt": "..." }` |
| `_error` | The query failed after retries, or the JSON envelope drifted / parse threw | `{ "_error": true, "filters": {...}, "message": "...", "fetchedAt": "..." }` |

`_baseline`/`_noData` keep a zero-delta run green and auditable rather than pushing a silent empty
dataset. A first run seeds the baseline and reports `_baseline`; subsequent runs report only true
new/changed awards, or `_noData` when there were none.

### Pricing (pay-per-event)

One **`project-returned`** event is charged per new/changed award record pushed to the dataset.
Cost scales with the size of the delta, not runtime or window size. Use `textSearch` / `fundingIc` /
`fiscalYears` / `awardAmountMin` / `maxResults` to keep spend proportional to signal. The intended price
band and the reasoning behind the single-event model are in `docs/PRICING.md` —
**documented-only; the live `$/event` value is owner-gated / DEFERRED** and no on-platform pricing is
set in this build. (Live price shown on the Store page once published.)

### Data source & attribution

All NIH RePORTER data is U.S. government public domain (Title 17 U.S.C.) — freely available, no fees, no
licensing restrictions, no registration, no API key. Attribution is **not** a licence condition (unlike
NVD's mandated string); we carry a courtesy source credit — *"Data courtesy of the NIH RePORTER API
(U.S. National Institutes of Health)."* — on every record and in this README as good practice. Full
compliance record: `COMPLIANCE.md`.

### Maintenance notes

- **POST query API, not a GET string.** RePORTER takes a JSON `criteria` body at
  `/v2/projects/search`; paging is `offset`/`limit` against `meta.total`, not a query-string cursor.
  Confirm the exact v2 `criteria` field names + response envelope against the live schema when the
  fetch layer lands (slice 2) — this scaffold fixes the contract from documented shapes.
- **15,000-record search ceiling.** `offset + limit` may not exceed ~15k; a broad query must be
  narrowed (fiscal year / IC / award-notice window), not paged past the cap. The paginator stops at the
  ceiling and surfaces truncation so the high-water-mark is not advanced past an incomplete pass.
- **1 req/sec rate limit.** The fetch layer runs a token bucket sized to 1 request/second + exponential
  backoff on 429/5xx. There is no API key to raise it — the limit is fixed for everyone.
- **Awards mutate — `appl_id` is the key.** A supplement revises the amount, a no-cost extension moves
  the end date, an abstract lands late. Keying the fingerprint on `appl_id` (not `core_project_num`)
  keeps each award year distinct and makes those revisions first-class `changed` events.
- **Windowed on `award_notice_date`.** The delta cursor is the award-notice date; the high-water-mark
  advances only after a clean, untruncated pass. RePORTER exposes no reliable "last modified" field, so
  mutation detection is best-effort within whatever window is pulled (documented honestly, not oversold).
- **Courtesy `User-Agent`** — sent on every request (`USER_AGENT` const).

# Actor input Schema

## `textSearch` (type: `string`):

Optional free-text passed to RePORTER `advanced_text_search` — matched against project title, abstract, and terms. Space-separated words are ANDed. Empty = no text filter.

## `orgNames` (type: `array`):

Optional list of grantee organization names (RePORTER `org_names`, matched as contains). Empty = all organizations.

## `piNames` (type: `array`):

Optional list of PI names (RePORTER `pi_names` any-name match). Empty = all investigators.

## `fundingIc` (type: `array`):

Optional list of NIH Institute/Center or agency abbreviations to restrict funding to (RePORTER `agencies`, e.g. NCI, NHLBI, NIAID). Empty = all ICs.

## `fiscalYears` (type: `array`):

Optional list of fiscal years to restrict to (RePORTER `fiscal_years`, e.g. 2026). Empty = all years within the award-notice window.

## `awardAmountMin` (type: `integer`):

Restrict to awards at/above this total dollar amount (maps to RePORTER `award_amount_range.min_amount`). Server-side filter. 0 = no floor.

## `since` (type: `string`):

Lower bound of the award-notice window — maps to RePORTER `award_notice_date.from_date` (YYYY-MM-DD). Leave empty to default to a recent trailing window. Ignored if 'Only new/changed since last run' is on (the stored high-water-mark drives the cursor instead).

## `until` (type: `string`):

Optional upper bound of the award-notice window (maps to RePORTER `award_notice_date.to_date`, YYYY-MM-DD). Leave empty for now (up to current date).

## `monitorNewOnly` (type: `boolean`):

Persist a per-award fingerprint (application id → award amount + project-end date + funding IC + abstract/terms presence) in the Actor's key-value store and, on the next run, emit only awards that are newly-seen OR whose fingerprint changed (a supplement revising the amount, a no-cost extension moving the end date, a later-added abstract). Turns this Actor into a first-seen + change monitor across scheduled runs. The award-notice high-water-mark drives the delta window automatically.

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

Cap the total number of award records emitted. 0 = no cap (page until the window is exhausted, honoring the 500-per-page ceiling, the 15,000-record search limit, and the 1 req/sec rate limit).

## `proxyConfiguration` (type: `object`):

Optional. The RePORTER API is a clean, open, public JSON host and needs NO proxy. You may enable Apify Proxy only to distribute requests across IPs for very large historical pulls. Default: no proxy.

## Actor input object example

```json
{
  "textSearch": "CRISPR gene therapy",
  "orgNames": [
    "STANFORD UNIVERSITY",
    "JOHNS HOPKINS UNIVERSITY"
  ],
  "piNames": [
    "Doudna"
  ],
  "fundingIc": [
    "NCI",
    "NIAID"
  ],
  "fiscalYears": [
    "2026"
  ],
  "awardAmountMin": 0,
  "since": "2026-07-01",
  "until": "2026-07-10",
  "monitorNewOnly": true,
  "maxResults": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `awards` (type: `string`):

One normalized NIH RePORTER research award per item, first-seen or re-emitted on change. Rendered as the Awards table (see the dataset 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("bytehavenstudios/nih-reporter-award-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("bytehavenstudios/nih-reporter-award-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call bytehavenstudios/nih-reporter-award-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NIH RePORTER Award Monitor",
        "description": "First-seen and change-detection over the live NIH RePORTER research-award feed. Polls the v2 projects API and normalizes each award to one flat record (IDs, title, PI, organization, fiscal year, amount, funding IC, dates, abstract), emitting new awards plus re-emits on changes. Keyless.",
        "version": "0.1",
        "x-build-id": "xsAYezsiwCuomOOpc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bytehavenstudios~nih-reporter-award-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bytehavenstudios-nih-reporter-award-monitor",
                "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/bytehavenstudios~nih-reporter-award-monitor/runs": {
            "post": {
                "operationId": "runs-sync-bytehavenstudios-nih-reporter-award-monitor",
                "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/bytehavenstudios~nih-reporter-award-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-bytehavenstudios-nih-reporter-award-monitor",
                "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": {
                    "textSearch": {
                        "title": "Text search",
                        "type": "string",
                        "description": "Optional free-text passed to RePORTER `advanced_text_search` — matched against project title, abstract, and terms. Space-separated words are ANDed. Empty = no text filter."
                    },
                    "orgNames": {
                        "title": "Organizations",
                        "type": "array",
                        "description": "Optional list of grantee organization names (RePORTER `org_names`, matched as contains). Empty = all organizations.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "piNames": {
                        "title": "Principal investigators",
                        "type": "array",
                        "description": "Optional list of PI names (RePORTER `pi_names` any-name match). Empty = all investigators.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fundingIc": {
                        "title": "Funding IC / agency",
                        "type": "array",
                        "description": "Optional list of NIH Institute/Center or agency abbreviations to restrict funding to (RePORTER `agencies`, e.g. NCI, NHLBI, NIAID). Empty = all ICs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fiscalYears": {
                        "title": "Fiscal years",
                        "type": "array",
                        "description": "Optional list of fiscal years to restrict to (RePORTER `fiscal_years`, e.g. 2026). Empty = all years within the award-notice window.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "awardAmountMin": {
                        "title": "Minimum award amount (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Restrict to awards at/above this total dollar amount (maps to RePORTER `award_amount_range.min_amount`). Server-side filter. 0 = no floor.",
                        "default": 0
                    },
                    "since": {
                        "title": "Awarded since (delta cursor)",
                        "type": "string",
                        "description": "Lower bound of the award-notice window — maps to RePORTER `award_notice_date.from_date` (YYYY-MM-DD). Leave empty to default to a recent trailing window. Ignored if 'Only new/changed since last run' is on (the stored high-water-mark drives the cursor instead)."
                    },
                    "until": {
                        "title": "Awarded until (optional upper bound)",
                        "type": "string",
                        "description": "Optional upper bound of the award-notice window (maps to RePORTER `award_notice_date.to_date`, YYYY-MM-DD). Leave empty for now (up to current date)."
                    },
                    "monitorNewOnly": {
                        "title": "Only new/changed since last run",
                        "type": "boolean",
                        "description": "Persist a per-award fingerprint (application id → award amount + project-end date + funding IC + abstract/terms presence) in the Actor's key-value store and, on the next run, emit only awards that are newly-seen OR whose fingerprint changed (a supplement revising the amount, a no-cost extension moving the end date, a later-added abstract). Turns this Actor into a first-seen + change monitor across scheduled runs. The award-notice high-water-mark drives the delta window automatically.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max awards per run",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the total number of award records emitted. 0 = no cap (page until the window is exhausted, honoring the 500-per-page ceiling, the 15,000-record search limit, and the 1 req/sec rate limit).",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. The RePORTER API is a clean, open, public JSON host and needs NO proxy. You may enable Apify Proxy only to distribute requests across IPs for very large historical pulls. Default: no proxy.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
