# Zentra Trace Normalizer (`zentrafoundry/zentra-trace-normalizer`) Actor

Convert agent traces into normalized spans, calls, errors, cost rows, and evidence datasets.

- **URL**: https://apify.com/zentrafoundry/zentra-trace-normalizer.md
- **Developed by:** [Zentra](https://apify.com/zentrafoundry) (community)
- **Categories:** AI, Agents, Developer tools
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 result delivereds

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

## Zentra Trace Normalizer

Inspect zentra trace normalizer workflows and return policy decisions, risk flags, cost notes, trace evidence, and recommended actions.

### What this Actor does

### What it does

- Processes configured public sources or user-provided records for focused zentra trace normalizer monitoring.
- Emits structured rows with source references, stable identifiers, confidence, warnings, and run summary fields.
- Supports sample-mode runs so Apify Store QA and first-time users can inspect output without depending on live third-party availability.

### What it does not do

- Does not scrape private, login-only, paywalled, or access-restricted data unless the user provides approved credentials for a source they control.
- Does not guarantee every field is available from every source; missing or blocked fields are returned as warnings or nulls.
- Does not make legal, financial, compliance, procurement, medical, safety, or regulatory decisions.

### Who this is for

AI operations, security, governance, platform, and automation teams use this actor when they need focused zentra trace normalizer output instead of a broad generic scraper or manual checking.

### Buyer outcomes

- Inspect zentra trace normalizer behavior before it creates avoidable cost, safety, or trust issues.
- Prioritize review with policy decisions, risk levels, budget impact, trace evidence, and recommended actions.
- Route blocked, approved, or review-required events into audit logs and operational workflows.

### Data sources

### Sources monitored

- [Zentra AgentOps Suite roadmap](https://zentra.nimblique.studio)
- [Apify publishing/Store](https://docs.apify.com/platform/actors/publishing)
- [Apify pay-per-event monetization](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event)
- [Apify datasets/storage](https://docs.apify.com/platform/storage/dataset)

### Input

- `sourceMode`: use `sample` for a safe smoke run, or configured modes for trace/tool-call inputs.
- `startUrls`: optional public actor, policy, MCP manifest, or evidence URLs when the workflow uses URL-backed review.
- `sourceIds`: approved policy, dataset, manifest, or trace source identifiers.
- `maxItems`: bounded number of decisions, findings, or reports to emit.
- `watchlistTerms`: policy names, tools, vendors, domains, or risk terms to prioritize.
- `webhookUrl`: optional destination for review-required decisions or audit reports.
- `outputMode`: use sample records for Store validation or production output for normal runs.

### How it transforms the input

- Input: agent trace, tool-call request, MCP manifest, actor metadata, policy rule, or run evidence.
- Transformation: apply policy, risk, budget, permission, side-effect, or audit checks.
- Output: allow/block/review decisions, matched policy, risk score, budget impact, reason, and recommended next action.

### Output

The actor returns structured AgentOps records for tool-call decisions, policy results, budget/cost signals, prompt-injection review, repair diagnosis, trace evidence, or audit reports.

Family-specific fields to expect:

- `agentGoal`: What the agent or workflow was trying to accomplish.
- `toolCall`: Requested tool name, arguments, and execution context.
- `policyDecision`: Allow, block, review, or escalation decision.
- `riskLevel`: Risk level assigned to the action or workflow.
- `budgetImpact`: Estimated or observed cost impact.
- `sideEffectRisk`: Potential external, write, payment, or account side-effect risk.
- `recommendedAction`: Operational next step for the reviewer or automation.
- `auditEvidence`: Trace, policy, manifest, or run evidence used in the decision.

- `recordId`: Stable record ID for exports, dedupe, and downstream joins.
- `title`: Human-readable record title for review and export.
- `sourceName`: Source identifier used to trace where the record came from.
- `sourceUrl`: Direct source URL for review and audit.
- `dedupeKey`: Stable key used for delta mode and duplicate suppression.
- `retrievedAt`: Timestamp showing when the actor retrieved or generated this record.
- `score`: Normalized field for filtering, routing, or downstream review.
- `scoreReasons`: Buyer-readable explanation for the score or match.
- `confidence`: Normalized field for filtering, routing, or downstream review.
- `errors`: Normalized field for filtering, routing, or downstream review.
- `runSummary`: Run-level summary for counts, filters, charges, and next actions.

### Pricing

This actor uses Apify pay-per-event pricing. Current public listing guidance: $29-$49 / 1,000 launch validation records until public data proof is complete. Charges are tied to buyer-visible value events such as `trace-normalized`, `span-block`, `cost-aggregation`, `dataset-processed`, `record-saved`, `enriched-record`. Small validation runs are supported so you can inspect output before scaling a schedule.

- `trace-normalized`: Charge after producing one trace normalized. Typical price: $0.080. A run that produces 10 matching records charges only for the matched buyer-value events and remains capped by the run limit.
- `span-block`: Charge after producing up to 1,000 spans normalized. Typical price: $0.030. A run that produces 10 matching records charges only for the matched buyer-value events and remains capped by the run limit.
- `cost-aggregation`: Charge after producing one trace cost aggregation. Typical price: $0.050. A run that produces 10 matching records charges only for the matched buyer-value events and remains capped by the run limit.
- `dataset-processed`: Base charge when Zentra Trace Normalizer writes a non-empty default dataset. Typical price: $0.011. A run that produces 10 matching records charges only for the matched buyer-value events and remains capped by the run limit.
- `first-run-cap`: Recommended first run budget cap. Typical price: $3.830. Start with the default small run, inspect the dataset, then raise maxItems or schedule recurring runs.

### API example

```bash
curl -X POST "https://api.apify.com/v2/actors/zentrafoundry~zentra-trace-normalizer/runs" \
+  -H "Authorization: Bearer $APIFY_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"maxItems":10,"sourceIds":["AGENTOPS-SUITE","APIFY-PUBLISH","APIFY-PPE"],"includeSourceUrls":true,"includeMatchReasons":true,"outputMode":"buyer-ready-records"}'
````

### Demo run

### Recommended first run

```json
{
    "maxItems": 10,
    "sourceIds": [
        "AGENTOPS-SUITE",
        "APIFY-PUBLISH",
        "APIFY-PPE"
    ],
    "includeSourceUrls": true,
    "includeMatchReasons": true,
    "outputMode": "buyer-ready-records"
}
```

### Sample output

Review the real stored sample from the latest successful quality run: https://zentra.nimblique.studio/external/actor-review/samples/zentra-trace-normalizer.json

### Recommended public tasks

```json
[
    {
        "name": "Review 10 agent/tool decisions",
        "description": "Low-cost validation run for checking policy, risk, cost, and action fields.",
        "input": {
            "maxItems": 10,
            "sourceIds": [
                "AGENTOPS-SUITE",
                "APIFY-PUBLISH",
                "APIFY-PPE"
            ],
            "includeSourceUrls": true,
            "includeMatchReasons": true,
            "outputMode": "buyer-ready-records",
            "actorSlug": "zentra-trace-normalizer"
        }
    },
    {
        "name": "Daily AgentOps decision review",
        "description": "Recurring review batch for tool-call risk, cost guardrails, and audit evidence.",
        "schedule": "Daily during local business hours",
        "input": {
            "maxItems": 25,
            "sourceIds": [
                "AGENTOPS-SUITE",
                "APIFY-PUBLISH",
                "APIFY-PPE"
            ],
            "includeSourceUrls": true,
            "includeMatchReasons": true,
            "outputMode": "buyer-ready-records",
            "actorSlug": "zentra-trace-normalizer"
        }
    }
]
```

### Example use cases

- Review zentra trace normalizer decisions before high-risk tool calls execute.
- Route policy violations, cost guardrails, and prompt-injection findings into audit logs or review queues.
- Compare agent runs by risk, confidence, budget impact, and recommended next action.
- Create customer-facing evidence for safer AI-agent operations.

### Trust and compliance

- Uses Zentra AgentOps Suite roadmap, Apify publishing/Store, Apify pay-per-event monetization.
- Keeps source URLs and source identifiers in output records for auditability.
- Does not require private credentials unless a source is explicitly configured for approved authenticated access.
- AgentOps outputs should be logged and reviewed before enforcing high-impact production decisions.

### Reliability and QA

- Prefilled Apify Store QA input runs in sample mode and should finish within the automated quality window.
- Empty input is handled with deterministic sample or diagnostic output instead of a crash.
- Demo/sample runs suppress buyer-value charges while still writing representative dataset rows.
- Production runs use bounded `maxItems`, source references, warnings, and run summaries so blocked or changed targets are visible.

### Limitations

- Results depend on public-source availability, source uptime, and source update cadence.
- Public sources can revise records after publication; rerun scheduled tasks for fresh evidence.
- Scores and match reasons are decision-support signals, not legal, financial, procurement, medical, safety, or regulatory advice.
- Large production runs can cost more than the default smoke run; start small, inspect output, then scale schedules.

### Legal and responsible use

Use this Actor only for public data or data you are authorized to process. You are responsible for complying with applicable laws, marketplace terms, robots policies, privacy rules, and source-specific limits.

### Support

Open an issue on the Actor page with the run ID, input summary, expected result, and observed result. Do not include secrets, cookies, auth headers, or private account data.

### FAQ

**Can I run this without URLs?** Yes. The default `sample` mode is designed to succeed without user-supplied URLs, and URL-backed runs can use `startUrls` when needed.

**Can I schedule it?** Yes. Use `sinceLastRun`, `watchlistTerms`, and optional `webhookUrl` to turn the actor into a recurring alert or report workflow.

**How do I verify value before scaling?** Run the recommended first-run input, review the sample output fields, then increase `maxItems` or schedule recurring runs after the dataset matches your use case.

# Actor input Schema

## `buyerQuery` (type: `string`):

Buyer-safe query or scope for the records returned by this product.

## `taskIntent` (type: `string`):

Stable product-specific purpose for this saved Apify task.

## `sourceMode` (type: `string`):

Sample emits public-safe Apify Actor Record rows. Approved live source mode keeps the same output fields and only uses owner-approved public URLs.

## `outputMode` (type: `string`):

Use sample records for Apify Store QA or buyer-ready records for approved Apify Actor Record delivery.

## `startUrls` (type: `array`):

Public URLs to use for live Apify Actor Record extraction after source-policy approval. Leave empty for sample mode.

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

Caps the number of Apify Actor Record rows written to the dataset.

## `perSourceLimit` (type: `integer`):

Caps validated rows from any one source before cross-source deduplication.

## `maxTotalChargeUsd` (type: `number`):

Buyer-selected spend ceiling; the Apify run-level maximum remains authoritative.

## `overallTimeoutSecs` (type: `integer`):

Stops additional source work once the bounded run deadline is reached.

## `requestTimeoutSecs` (type: `integer`):

Timeout applied independently to each approved source request.

## `maxRequestRetries` (type: `integer`):

Bounded retry count for transient source failures.

## `sinceLastRun` (type: `boolean`):

Uses stable Actor state to skip logical records delivered by earlier runs.

## `deltaMode` (type: `boolean`):

Preserves stable deduplication keys for recurring tasks and schedules.

## Actor input object example

```json
{
  "buyerQuery": "buyer-ready records with source evidence",
  "taskIntent": "buyer-ready-product-run",
  "sourceMode": "sample",
  "outputMode": "sample-records",
  "startUrls": [],
  "maxItems": 1,
  "perSourceLimit": 25,
  "maxTotalChargeUsd": 5,
  "overallTimeoutSecs": 900,
  "requestTimeoutSecs": 30,
  "maxRequestRetries": 2,
  "sinceLastRun": false,
  "deltaMode": true
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "buyerQuery": "buyer-ready records with source evidence",
    "taskIntent": "buyer-ready-product-run",
    "sourceMode": "sample",
    "outputMode": "sample-records",
    "startUrls": [],
    "maxItems": 1,
    "perSourceLimit": 25,
    "maxTotalChargeUsd": 5,
    "overallTimeoutSecs": 900,
    "requestTimeoutSecs": 30,
    "maxRequestRetries": 2,
    "sinceLastRun": false,
    "deltaMode": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("zentrafoundry/zentra-trace-normalizer").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 = {
    "buyerQuery": "buyer-ready records with source evidence",
    "taskIntent": "buyer-ready-product-run",
    "sourceMode": "sample",
    "outputMode": "sample-records",
    "startUrls": [],
    "maxItems": 1,
    "perSourceLimit": 25,
    "maxTotalChargeUsd": 5,
    "overallTimeoutSecs": 900,
    "requestTimeoutSecs": 30,
    "maxRequestRetries": 2,
    "sinceLastRun": False,
    "deltaMode": True,
}

# Run the Actor and wait for it to finish
run = client.actor("zentrafoundry/zentra-trace-normalizer").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 '{
  "buyerQuery": "buyer-ready records with source evidence",
  "taskIntent": "buyer-ready-product-run",
  "sourceMode": "sample",
  "outputMode": "sample-records",
  "startUrls": [],
  "maxItems": 1,
  "perSourceLimit": 25,
  "maxTotalChargeUsd": 5,
  "overallTimeoutSecs": 900,
  "requestTimeoutSecs": 30,
  "maxRequestRetries": 2,
  "sinceLastRun": false,
  "deltaMode": true
}' |
apify call zentrafoundry/zentra-trace-normalizer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=zentrafoundry/zentra-trace-normalizer",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zentra Trace Normalizer",
        "description": "Convert agent traces into normalized spans, calls, errors, cost rows, and evidence datasets.",
        "version": "1.0",
        "x-build-id": "taEFDRfb6dJYXxSVv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zentrafoundry~zentra-trace-normalizer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zentrafoundry-zentra-trace-normalizer",
                "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/zentrafoundry~zentra-trace-normalizer/runs": {
            "post": {
                "operationId": "runs-sync-zentrafoundry-zentra-trace-normalizer",
                "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/zentrafoundry~zentra-trace-normalizer/run-sync": {
            "post": {
                "operationId": "run-sync-zentrafoundry-zentra-trace-normalizer",
                "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": [
                    "sourceMode"
                ],
                "properties": {
                    "buyerQuery": {
                        "title": "Apify Actor Record query",
                        "type": "string",
                        "description": "Buyer-safe query or scope for the records returned by this product.",
                        "default": "buyer-ready records with source evidence"
                    },
                    "taskIntent": {
                        "title": "Apify Actor Record task intent",
                        "type": "string",
                        "description": "Stable product-specific purpose for this saved Apify task.",
                        "default": "buyer-ready-product-run"
                    },
                    "sourceMode": {
                        "title": "Run sample or approved live sources",
                        "enum": [
                            "sample",
                            "startUrls"
                        ],
                        "type": "string",
                        "description": "Sample emits public-safe Apify Actor Record rows. Approved live source mode keeps the same output fields and only uses owner-approved public URLs.",
                        "default": "sample"
                    },
                    "outputMode": {
                        "title": "Apify Actor Record output mode",
                        "enum": [
                            "sample-records",
                            "buyer-ready-records"
                        ],
                        "type": "string",
                        "description": "Use sample records for Apify Store QA or buyer-ready records for approved Apify Actor Record delivery.",
                        "default": "sample-records"
                    },
                    "startUrls": {
                        "title": "Approved Apify Actor Record source URLs",
                        "type": "array",
                        "description": "Public URLs to use for live Apify Actor Record extraction after source-policy approval. Leave empty for sample mode.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "Approved public Apify Actor Record source URL."
                                }
                            }
                        },
                        "default": []
                    },
                    "maxItems": {
                        "title": "Maximum Apify Actor Record rows",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Caps the number of Apify Actor Record rows written to the dataset.",
                        "default": 1
                    },
                    "perSourceLimit": {
                        "title": "Maximum rows per source",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Caps validated rows from any one source before cross-source deduplication.",
                        "default": 25
                    },
                    "maxTotalChargeUsd": {
                        "title": "Maximum total charge (USD)",
                        "minimum": 0.01,
                        "maximum": 1000,
                        "type": "number",
                        "description": "Buyer-selected spend ceiling; the Apify run-level maximum remains authoritative.",
                        "default": 5
                    },
                    "overallTimeoutSecs": {
                        "title": "Overall timeout seconds",
                        "minimum": 30,
                        "maximum": 3600,
                        "type": "integer",
                        "description": "Stops additional source work once the bounded run deadline is reached.",
                        "default": 900
                    },
                    "requestTimeoutSecs": {
                        "title": "Source request timeout seconds",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Timeout applied independently to each approved source request.",
                        "default": 30
                    },
                    "maxRequestRetries": {
                        "title": "Maximum source retries",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Bounded retry count for transient source failures.",
                        "default": 2
                    },
                    "sinceLastRun": {
                        "title": "Only emit new logical records",
                        "type": "boolean",
                        "description": "Uses stable Actor state to skip logical records delivered by earlier runs.",
                        "default": false
                    },
                    "deltaMode": {
                        "title": "Delta mode",
                        "type": "boolean",
                        "description": "Preserves stable deduplication keys for recurring tasks and schedules.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
