# npm & PyPI Dependency Risk Report (`taroyamada/package-portfolio-upgrade-risk-report`) Actor

Audit npm and PyPI packages with official registry and OSV evidence. Deliver upgrade-risk rows, vulnerability alerts, portfolio reports, and exports.

- **URL**: https://apify.com/taroyamada/package-portfolio-upgrade-risk-report.md
- **Developed by:** [naoki anzai](https://apify.com/taroyamada) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 package risk rows

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/docs.md):

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

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

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

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

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

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

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

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

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


# README

## npm & PyPI Dependency Risk Report

**Buyer:** engineering, security, and platform teams that need a small, source-linked queue of package upgrade risks across npm and PyPI portfolios. **Input:** exact public package names, ecosystems, and installed versions. **Output:** a report-first portfolio row followed by changed package risk rows, actionable upgrade alerts, and an optional export row.

This actor reads official npm registry metadata, the official PyPI JSON API, and OSV advisories. GitHub repository metadata is optional enrichment only; npm/PyPI/OSV analysis completes without a GitHub token.

<!-- phase10-low-friction-trial:start -->
### Start with a low-cost paid trial

Use this capped input to verify the source and output shape before buying a full report. It disables the report and export events, caps the run at **$0.50**, and charges only delivered `package-risk-row` rows at **$0.010 each**. A zero-row run has zero event charge.

[Open the maintained starter input](https://github.com/luxslime/apify-paid-report-starter-kits/blob/master/inputs/package-portfolio-upgrade-risk-report.json) if you prefer a standalone JSON file.

```json
{
  "packages": [
    {
      "name": "lodash",
      "ecosystem": "npm",
      "version": "4.17.20"
    }
  ],
  "includeGitHub": false,
  "initialRunMode": "emit_backfill",
  "generateReport": false,
  "emitRawRows": true,
  "emitUnchanged": false,
  "emitExport": false,
  "maxChargeUsd": 0.5,
  "dryRun": false
}
````

When the result fits your workflow, enable the full `package-portfolio-risk-report` output (**$9.00 per delivered report**) and set a buyer-approved `maxChargeUsd`.

### Input

```json
{
  "packages": [
    { "name": "lodash", "ecosystem": "npm", "version": "4.17.20" },
    { "name": "requests", "ecosystem": "PyPI", "version": "2.31.0" }
  ],
  "dryRun": false,
  "maxChargeUsd": 25
}
```

Each package should include an exact installed `version` for meaningful upgrade comparison. `repository` is optional and is used only when GitHub enrichment is enabled. `baselineOnly` saves the current snapshot without producing rows. Request controls include `requestTimeoutSeconds`, `rateLimitMs`, `maxRetries`, `backoffBaseMs`, and `maxBackoffMs`.

### Output

Rows use `rowType` values `package_portfolio_risk_report`, `package_risk`, `package_upgrade_risk_alert`, and `package_risk_export`. Every billable row includes `billingEventName`, a deterministic `stableKey`, an `idempotencyKey`, official `sources`, `limitations`, and `prohibitedInterpretations`.

The report row is emitted first when a change is found. A package risk row carries current and latest versions, upgrade kind, risk level, advisory IDs and severities, repository metadata, and source URLs. An alert row carries the reason and a suggested review action. The output also contains `deliveryAudit` with planned and captured charges, event counts, idempotency keys, `maxChargeUsd`, delivery status, and state-commit status.

### Examples

#### 1. Establish a free baseline

Run once with the portfolio and `baselineOnly: true`, or with the first live run. The snapshot is saved and the run returns zero dataset rows and zero billable events.

```json
{
  "packages": [
    { "name": "fastify", "ecosystem": "npm", "version": "4.28.1" },
    { "name": "urllib3", "ecosystem": "PyPI", "version": "2.2.2" }
  ],
  "baselineOnly": true,
  "dryRun": false
}
```

#### 2. Run a change-aware portfolio report

Use the same portfolio on a later run. New registry versions or OSV advisory changes produce the configured report and risk events; an unchanged portfolio produces zero rows and zero charges.

Set `initialRunMode` to `baseline_only` for scheduled monitoring. The first successful run saves the official-source snapshot with zero rows and zero charge. Use `emit_backfill` only when you explicitly want an initial charged report.

```json
{
  "packages": [
    { "name": "fastify", "ecosystem": "npm", "version": "4.28.1" },
    { "name": "urllib3", "ecosystem": "PyPI", "version": "2.2.2" }
  ],
  "generateReport": true,
  "maxChargeUsd": 20,
  "dryRun": false
}
```

#### 3. Add optional GitHub context and a handoff export

Set `includeGitHub: true` and provide `githubToken` only when public repository metadata is useful. Without a token, GitHub is explicitly marked skipped and the required official sources still run. `emitExport` adds one export event when a change is found.

```json
{
  "packages": [
    { "name": "pydantic", "ecosystem": "PyPI", "version": "2.8.2", "repository": "https://github.com/pydantic/pydantic" }
  ],
  "includeGitHub": true,
  "emitExport": true,
  "maxChargeUsd": 20,
  "dryRun": false
}
```

### Report-first sample

Dry runs make the report-first shape visible without network calls or charges. The advisory below is deliberately labeled illustrative.

```json
[
  {
    "rowType": "package_portfolio_risk_report",
    "billingEventName": "package-portfolio-risk-report",
    "reportFirst": true,
    "changedPackageCount": 1,
    "advisoryCount": 1
  },
  {
    "rowType": "package_risk",
    "billingEventName": "package-risk-row",
    "packageName": "lodash",
    "ecosystem": "npm",
    "currentVersion": "4.17.20",
    "latestVersion": "4.17.21",
    "riskLevel": "high",
    "vulnerabilityCount": 1
  },
  {
    "rowType": "package_upgrade_risk_alert",
    "billingEventName": "package-upgrade-risk-alert",
    "alertReason": "known_vulnerability"
  }
]
```

### Pricing

This actor uses PAY\_PER\_EVENT pricing. There is no start charge. A complete planned event total must fit `maxChargeUsd` before delivery begins.

| Event | Price | When it is emitted |
| --- | ---: | --- |
| `package-risk-row` | $0.01 | Each changed package risk row |
| `package-upgrade-risk-alert` | $0.25 | Each actionable changed package alert |
| `package-portfolio-risk-report` | $9.00 | One changed portfolio report |
| `package-risk-export` | $5.00 | One optional changed handoff export |

First-run baselines and unchanged runs emit zero default dataset rows and zero billable events. Dry runs also emit no charges. No start or heartbeat event is pushed.

### Compliance and operating limits

Use package names supplied by the buyer or an authorized inventory. The actor calls public official endpoints only and records source URLs. It does not fetch private registries, private repositories, credentials, source code, or contact data. GitHub authorization is optional and its token is never written to output.

OSV matches and registry versions are evidence for triage, not a finding that a package is exploitable or that an upgrade is compatible. License fields are reported metadata, not legal advice. Network calls have bounded timeouts, retry only on timeout/rate-limit/server errors, exponential backoff, and a minimum request interval. Incomplete source coverage produces no billable rows and cannot advance state.

State load and save are fail closed. Delivery is idempotency-keyed, preflighted against `maxChargeUsd`, and written to `delivery-audit.json` or the Apify audit key. A missing `chargedCount` or an event charge-limit response stops delivery rather than treating an uncharged row as successful.

### No-change behavior

The actor stores a fingerprint of official registry and OSV observations per package. The first successful live run establishes that fingerprint at zero charge. Later runs compare fingerprints; when nothing changed, the output contains zero rows, zero `chargedCount`, and zero charge. State is not advanced after a source error or delivery failure.

### Run the next report

- Inspect npm package metadata with [npm Package Dependency Intelligence](https://apify.com/taroyamada/npm-package-dependency-intelligence).
- Inspect Python package metadata with [PyPI Package Dependency Intelligence](https://apify.com/taroyamada/pypi-package-dependency-intelligence).

### See also

- [Source compliance](docs/source-compliance.md)
- [Competitive snapshot](docs/store-competitive-snapshot.md)
- [Integration guide](docs/integration-guide.md)
- [Sample output](docs/sample-output.json)
- [Input schema](INPUT_SCHEMA.json)

# Actor input Schema

## `watchlists` (type: `array`):

Optional named package portfolios. Each item may contain a name and packages array; top-level packages remains supported.

## `monitorKey` (type: `string`):

Stable key that isolates the saved comparison baseline.

## `initialRunMode` (type: `string`):

baseline\_only saves the first snapshot with zero rows and zero charge; emit\_backfill emits a report on the first run.

## `packages` (type: `array`):

Public package names and installed versions to assess.

## `includeGitHub` (type: `boolean`):

Optional. GitHub is skipped when no token is supplied; npm/PyPI/OSV analysis remains complete.

## `githubToken` (type: `string`):

Optional token for public GitHub repository metadata. Never included in output.

## `baselineOnly` (type: `boolean`):

Save the current official-source snapshot and emit zero rows and zero charges.

## `generateReport` (type: `boolean`):

Generate one report row before package rows when changes are found.

## `emitRawRows` (type: `boolean`):

Emit per-package rows in addition to alerts and the portfolio report.

## `emitUnchanged` (type: `boolean`):

Reserved for compatibility. Unchanged monitoring runs always produce zero rows and zero charge.

## `emitExport` (type: `boolean`):

Generate one dataset JSON handoff row when changes are found.

## `dryRun` (type: `boolean`):

Return a report-first sample without network calls, state writes, or charges.

## `maxChargeUsd` (type: `number`):

The complete planned event total must fit this cap before any event is pushed.

## `requestTimeoutSeconds` (type: `integer`):

Request timeout seconds for this run.

## `rateLimitMs` (type: `integer`):

Minimum request interval ms for this run.

## `maxRetries` (type: `integer`):

Maximum retries for this run.

## `backoffBaseMs` (type: `integer`):

Backoff base ms for this run.

## `maxBackoffMs` (type: `integer`):

Maximum backoff ms for this run.

## `delivery` (type: `string`):

Delivery mode for this run.

## `webhookUrl` (type: `string`):

Optional HTTPS handoff after dataset event delivery.

## Actor input object example

```json
{
  "watchlists": [],
  "monitorKey": "",
  "initialRunMode": "baseline_only",
  "packages": [],
  "includeGitHub": false,
  "baselineOnly": false,
  "generateReport": true,
  "emitRawRows": false,
  "emitUnchanged": false,
  "emitExport": false,
  "dryRun": true,
  "maxChargeUsd": 50,
  "requestTimeoutSeconds": 30,
  "rateLimitMs": 250,
  "maxRetries": 2,
  "backoffBaseMs": 250,
  "maxBackoffMs": 4000,
  "delivery": "dataset"
}
```

# 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("taroyamada/package-portfolio-upgrade-risk-report").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("taroyamada/package-portfolio-upgrade-risk-report").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 taroyamada/package-portfolio-upgrade-risk-report --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=taroyamada/package-portfolio-upgrade-risk-report",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "npm & PyPI Dependency Risk Report",
        "description": "Audit npm and PyPI packages with official registry and OSV evidence. Deliver upgrade-risk rows, vulnerability alerts, portfolio reports, and exports.",
        "version": "0.1",
        "x-build-id": "WoxEpSIcNv2vikM5S"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/taroyamada~package-portfolio-upgrade-risk-report/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-taroyamada-package-portfolio-upgrade-risk-report",
                "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/taroyamada~package-portfolio-upgrade-risk-report/runs": {
            "post": {
                "operationId": "runs-sync-taroyamada-package-portfolio-upgrade-risk-report",
                "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/taroyamada~package-portfolio-upgrade-risk-report/run-sync": {
            "post": {
                "operationId": "run-sync-taroyamada-package-portfolio-upgrade-risk-report",
                "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": {
                    "watchlists": {
                        "title": "Portfolio watchlists",
                        "type": "array",
                        "description": "Optional named package portfolios. Each item may contain a name and packages array; top-level packages remains supported.",
                        "default": []
                    },
                    "monitorKey": {
                        "title": "Monitor key",
                        "type": "string",
                        "description": "Stable key that isolates the saved comparison baseline.",
                        "default": ""
                    },
                    "initialRunMode": {
                        "title": "Initial run mode",
                        "enum": [
                            "baseline_only",
                            "emit_backfill"
                        ],
                        "type": "string",
                        "description": "baseline_only saves the first snapshot with zero rows and zero charge; emit_backfill emits a report on the first run.",
                        "default": "baseline_only"
                    },
                    "packages": {
                        "title": "Package portfolio",
                        "minItems": 0,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Public package names and installed versions to assess.",
                        "default": []
                    },
                    "includeGitHub": {
                        "title": "Include GitHub enrichment",
                        "type": "boolean",
                        "description": "Optional. GitHub is skipped when no token is supplied; npm/PyPI/OSV analysis remains complete.",
                        "default": false
                    },
                    "githubToken": {
                        "title": "GitHub token",
                        "type": "string",
                        "description": "Optional token for public GitHub repository metadata. Never included in output."
                    },
                    "baselineOnly": {
                        "title": "Baseline only",
                        "type": "boolean",
                        "description": "Save the current official-source snapshot and emit zero rows and zero charges.",
                        "default": false
                    },
                    "generateReport": {
                        "title": "Generate portfolio report",
                        "type": "boolean",
                        "description": "Generate one report row before package rows when changes are found.",
                        "default": true
                    },
                    "emitRawRows": {
                        "title": "Emit package risk rows",
                        "type": "boolean",
                        "description": "Emit per-package rows in addition to alerts and the portfolio report.",
                        "default": false
                    },
                    "emitUnchanged": {
                        "title": "Emit unchanged rows",
                        "type": "boolean",
                        "description": "Reserved for compatibility. Unchanged monitoring runs always produce zero rows and zero charge.",
                        "default": false
                    },
                    "emitExport": {
                        "title": "Generate export row",
                        "type": "boolean",
                        "description": "Generate one dataset JSON handoff row when changes are found.",
                        "default": false
                    },
                    "dryRun": {
                        "title": "Dry run",
                        "type": "boolean",
                        "description": "Return a report-first sample without network calls, state writes, or charges.",
                        "default": true
                    },
                    "maxChargeUsd": {
                        "title": "Maximum charge USD",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "number",
                        "description": "The complete planned event total must fit this cap before any event is pushed.",
                        "default": 50
                    },
                    "requestTimeoutSeconds": {
                        "title": "Request timeout seconds",
                        "minimum": 2,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Request timeout seconds for this run.",
                        "default": 30
                    },
                    "rateLimitMs": {
                        "title": "Minimum request interval ms",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Minimum request interval ms for this run.",
                        "default": 250
                    },
                    "maxRetries": {
                        "title": "Maximum retries",
                        "minimum": 0,
                        "maximum": 4,
                        "type": "integer",
                        "description": "Maximum retries for this run.",
                        "default": 2
                    },
                    "backoffBaseMs": {
                        "title": "Backoff base ms",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Backoff base ms for this run.",
                        "default": 250
                    },
                    "maxBackoffMs": {
                        "title": "Maximum backoff ms",
                        "minimum": 0,
                        "maximum": 15000,
                        "type": "integer",
                        "description": "Maximum backoff ms for this run.",
                        "default": 4000
                    },
                    "delivery": {
                        "title": "Delivery mode",
                        "enum": [
                            "dataset",
                            "webhook"
                        ],
                        "type": "string",
                        "description": "Delivery mode for this run.",
                        "default": "dataset"
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "Optional HTTPS handoff after dataset event delivery."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```