# MCP Readiness Auditor (`junipr/mcp-readiness-auditor`) Actor

Audit tools/actors for MCP and AI-agent readiness: schemas, docs, examples, tasks, and outputs.

- **URL**: https://apify.com/junipr/mcp-readiness-auditor.md
- **Developed by:** [junipr](https://apify.com/junipr) (community)
- **Categories:** SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.50 / 1,000 schema validateds

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

## MCP Readiness Auditor

<!-- FIXED_INCLUSIVE_PPE_20260707_START -->
### Store Positioning

**Store title:** MCP Readiness Auditor

**Short description:** Audit tools/actors for MCP and AI-agent readiness: schemas, docs, examples, tasks, and outputs.

**SEO title:** MCP Readiness Auditor — API, schema, and developer QA

**SEO description:** Audit tools/actors for MCP and AI-agent readiness: schemas, docs, examples, tasks, and outputs. Use it to catch contract drift, schema mistakes, unsafe endpoint assumptions, and developer-tool quality issues before release.

**Categories:** SEO_TOOLS, DEVELOPER_TOOLS

**Keywords:** mcp, readiness, auditor, schema, api/developer qa

### Fixed-Inclusive PPE Pricing

This actor uses pay-per-event pricing. Event prices include Apify platform usage; users are not expected to pay a separate platform-usage pass-through charge for the configured pricing model.

- Tier: A1 — API/developer QA
- Primary event: `schema-validated` at $0.00650 base
- Default max charge: $10.00
- Store discounts: FREE/BRONZE base, SILVER discounted, GOLD deepest approved discount

Event set:

- `actor-start`: base $0.00500, GOLD $0.00400. MCP Readiness Auditor: charged when actor start is completed. The price includes Apify platform usage; no separate usage pass-through is intended.
- `schema-validated`: base $0.00650, GOLD $0.00520. MCP Readiness Auditor: charged when schema validated is completed. The price includes Apify platform usage; no separate usage pass-through is intended.
- `contract-rule-checked`: base $0.00390, GOLD $0.00312. MCP Readiness Auditor: charged when contract rule checked is completed. The price includes Apify platform usage; no separate usage pass-through is intended.
- `report-generated`: base $0.05000, GOLD $0.04000. MCP Readiness Auditor: charged when report generated is completed. The price includes Apify platform usage; no separate usage pass-through is intended.

### Public Task Concepts

- Validate MCP Readiness Auditor before release
- Run a bounded MCP Readiness Auditor QA check
- Generate developer QA evidence for MCP Readiness Auditor
- Extract evidence-backed mcp rows for client QA
- Prioritize mcp fixes before a launch or migration
<!-- FIXED_INCLUSIVE_PPE_20260707_END -->

Audit tools/actors for MCP and AI-agent readiness: schemas, docs, examples, tasks, and outputs.

This Actor is a premium Apify tool for the use case described below. It is designed for controlled runs with capped inputs, transparent pricing, and evidence-backed outputs.

### What It Does

MCP Readiness Auditor turns supplied source evidence into actor-specific dataset rows for ai-agent tooling workflows. It uses deterministic parsing, strict caps, supplied examples, and top-level fields that match the dataset schema.

### What It Does Not Do

- It does not claim outcomes beyond the supplied public evidence and configured run limits.
- It does not fetch URLs unless `fetchUrls` is explicitly enabled and the URLs are public sources you are allowed to process.
- It does not use unsupported AI claims or hidden enrichment.
- It does not replace legal, financial, medical, or compliance review.

### Input Fields

- `targets`: Source rows, snapshots, text, HTML, records, schemas, logs, or workflow details.
- `fetchUrls`: Defaults to `false` so you can validate supplied snapshots first. Enable it when you want the Actor to fetch public URLs within configured limits.
- `includeReport`: Writes JSON and Markdown artifacts when enabled.
- `maxTargets`: Conservative cap for small, predictable runs.
- `maxTextBytes`: Per-target text cap.

### Example Input

```json
{
  "targets": [
    {
      "sourceId": "actor-ready-for-mcp",
      "actorName": "dataset-qa-auditor",
      "text": "README includes input schema, output schema, dataset schema, example input, example output, public task examples, limitations, and troubleshooting.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "datasetId": {
            "type": "string",
            "description": "Dataset ID to audit.",
            "default": "sample"
          }
        }
      }
    },
    {
      "sourceId": "actor-needs-mcp-work",
      "actorName": "thin-actor",
      "text": "README says run the actor and check results. Missing output schema and examples.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "query": {
            "type": "string"
          }
        }
      }
    }
  ],
  "fetchUrls": false,
  "includeReport": true,
  "maxTargets": 2
}
````

### Output Fields

- `rowId`
- `sourceId`
- `sourceUrl`
- `sourceType`
- `status`
- `severity`
- `score`
- `summary`
- `recommendation`
- `checkedAt`
- `pricingTemplate`
- `pricingEventName`
- `toolName`
- `inputSchemaStatus`
- `outputSchemaStatus`
- `descriptionQuality`
- `exampleCoverage`
- `authDisclosure`
- `errorHandlingDisclosure`
- `agentReadinessScore`
- `fixHint`

### Example Output

```json
[
  {
    "rowId": "mcp-readiness-auditor_d6fedac65cd6f1a3",
    "sourceId": "actor-ready-for-mcp",
    "sourceUrl": null,
    "sourceType": "inline",
    "status": "ok",
    "severity": "low",
    "score": 92,
    "summary": "MCP Readiness Auditor produced actor-specific row 1 for actor-ready-for-mcp.",
    "recommendation": "Ready for agent tool catalog review.",
    "checkedAt": "2026-07-02T00:00:00.000Z",
    "pricingTemplate": "A1 — API/developer QA",
    "pricingEventName": "schema-validated",
    "toolName": "dataset-qa-auditor",
    "inputSchemaStatus": "documented",
    "outputSchemaStatus": "documented",
    "descriptionQuality": "specific",
    "exampleCoverage": "examples-present",
    "authDisclosure": "not-disclosed",
    "errorHandlingDisclosure": "not-documented",
    "agentReadinessScore": 80,
    "fixHint": "Ready for agent tool catalog review."
  },
  {
    "rowId": "mcp-readiness-auditor_8f2b1480fd4cd13e",
    "sourceId": "actor-needs-mcp-work",
    "sourceUrl": null,
    "sourceType": "inline",
    "status": "ok",
    "severity": "low",
    "score": 92,
    "summary": "MCP Readiness Auditor produced actor-specific row 1 for actor-needs-mcp-work.",
    "recommendation": "Ready for agent tool catalog review.",
    "checkedAt": "2026-07-02T00:00:00.000Z",
    "pricingTemplate": "A1 — API/developer QA",
    "pricingEventName": "schema-validated",
    "toolName": "thin-actor",
    "inputSchemaStatus": "documented",
    "outputSchemaStatus": "documented",
    "descriptionQuality": "thin",
    "exampleCoverage": "examples-present",
    "authDisclosure": "not-disclosed",
    "errorHandlingDisclosure": "not-documented",
    "agentReadinessScore": 80,
    "fixHint": "Ready for agent tool catalog review."
  }
]
```

### Public Task Concepts

Example tasks are included for common use cases and can be published as Apify public tasks after review/approval.

### Limitations

Use capped runs first, enable URL fetching only for public URLs you are allowed to process, and review evidence before using results in operational decisions. Store icon upload, public task publication, and live metadata changes are handled through the approved release process.

### FAQ

**Is this ready for scaled runs?** Start with the capped example tasks, confirm the evidence quality, then increase limits deliberately.

**How are costs controlled?** Costs are controlled with input caps and max-charge handling. See the pricing section for event prices and cost controls.

# Actor input Schema

## `targets` (type: `array`):

Targets with text, HTML, logs, records, schemas, previous/current snapshots, or workflow details.

## `urls` (type: `array`):

Optional URL shorthand. URLs are fetched only when Fetch URLs is enabled.

## `fetchUrls` (type: `boolean`):

Fetch source URL text over HTTP. Default is false so supplied snapshots can be validated first.

## `prompt` (type: `string`):

Optional natural-language goal or task prompt.

## `objective` (type: `string`):

Optional business objective for planning/report modes.

## `actorName` (type: `string`):

Optional actor slug/name for Apify creator ops modes.

## `brandName` (type: `string`):

Optional brand name for report and visibility modes.

## `records` (type: `array`):

Optional structured records for normalization, public data, or report modes.

## `targetSchema` (type: `object`):

Optional target schema or desired output fields.

## `inputSchema` (type: `object`):

Optional Apify actor input schema to audit or optimize.

## `steps` (type: `array`):

Optional workflow or cost-estimation steps.

## `availableActors` (type: `array`):

Optional actor slugs available to a chain planner.

## `visibilityRecords` (type: `array`):

Optional GEO/AEO visibility evidence records.

## `budgetUsd` (type: `number`):

Optional cost budget for estimator modes.

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

Alias for Max Targets/Maximum Records used by the Junipr actor baseline. When both are provided, actor-specific limits still apply.

## `includeReport` (type: `boolean`):

Write summary JSON and Markdown report artifacts to the key-value store.

## `maxTargets` (type: `integer`):

Maximum targets to process.

## `maxTextBytes` (type: `integer`):

Maximum text bytes to analyze per target field.

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

Validate input and write a dry-run summary without PPE charges or dataset output.

## `debug` (type: `boolean`):

Enable debug logs.

## Actor input object example

```json
{
  "targets": [],
  "urls": [],
  "fetchUrls": false,
  "prompt": "",
  "objective": "",
  "actorName": "",
  "brandName": "",
  "records": [],
  "targetSchema": {},
  "inputSchema": {},
  "steps": [],
  "availableActors": [],
  "visibilityRecords": [],
  "budgetUsd": 0,
  "maxItems": 2,
  "includeReport": true,
  "maxTargets": 2,
  "maxTextBytes": 120000,
  "dryRun": false,
  "debug": false
}
```

# Actor output Schema

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

Rows in the default dataset.

## `summary` (type: `string`):

Summary JSON in the key-value store when includeReport is enabled.

## `markdownReport` (type: `string`):

Markdown report in the key-value store when includeReport is enabled.

# 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("junipr/mcp-readiness-auditor").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("junipr/mcp-readiness-auditor").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 junipr/mcp-readiness-auditor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MCP Readiness Auditor",
        "description": "Audit tools/actors for MCP and AI-agent readiness: schemas, docs, examples, tasks, and outputs.",
        "version": "1.0",
        "x-build-id": "S1BWBSJQHPj3eWF6N"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/junipr~mcp-readiness-auditor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-junipr-mcp-readiness-auditor",
                "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/junipr~mcp-readiness-auditor/runs": {
            "post": {
                "operationId": "runs-sync-junipr-mcp-readiness-auditor",
                "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/junipr~mcp-readiness-auditor/run-sync": {
            "post": {
                "operationId": "run-sync-junipr-mcp-readiness-auditor",
                "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": {
                    "targets": {
                        "title": "Targets",
                        "type": "array",
                        "description": "Targets with text, HTML, logs, records, schemas, previous/current snapshots, or workflow details.",
                        "items": {
                            "type": "object"
                        },
                        "default": []
                    },
                    "urls": {
                        "title": "URLs To Fetch",
                        "type": "array",
                        "description": "Optional URL shorthand. URLs are fetched only when Fetch URLs is enabled.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "fetchUrls": {
                        "title": "Fetch URLs",
                        "type": "boolean",
                        "description": "Fetch source URL text over HTTP. Default is false so supplied snapshots can be validated first.",
                        "default": false
                    },
                    "prompt": {
                        "title": "Prompt",
                        "type": "string",
                        "description": "Optional natural-language goal or task prompt.",
                        "default": ""
                    },
                    "objective": {
                        "title": "Objective",
                        "type": "string",
                        "description": "Optional business objective for planning/report modes.",
                        "default": ""
                    },
                    "actorName": {
                        "title": "Actor Name",
                        "type": "string",
                        "description": "Optional actor slug/name for Apify creator ops modes.",
                        "default": ""
                    },
                    "brandName": {
                        "title": "Brand Name",
                        "type": "string",
                        "description": "Optional brand name for report and visibility modes.",
                        "default": ""
                    },
                    "records": {
                        "title": "Records",
                        "type": "array",
                        "description": "Optional structured records for normalization, public data, or report modes.",
                        "items": {
                            "type": "object"
                        },
                        "default": []
                    },
                    "targetSchema": {
                        "title": "Target Schema",
                        "type": "object",
                        "description": "Optional target schema or desired output fields.",
                        "default": {}
                    },
                    "inputSchema": {
                        "title": "Input Schema",
                        "type": "object",
                        "description": "Optional Apify actor input schema to audit or optimize.",
                        "default": {}
                    },
                    "steps": {
                        "title": "Workflow Steps",
                        "type": "array",
                        "description": "Optional workflow or cost-estimation steps.",
                        "items": {
                            "type": "object"
                        },
                        "default": []
                    },
                    "availableActors": {
                        "title": "Available Actors",
                        "type": "array",
                        "description": "Optional actor slugs available to a chain planner.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "visibilityRecords": {
                        "title": "Visibility Records",
                        "type": "array",
                        "description": "Optional GEO/AEO visibility evidence records.",
                        "items": {
                            "type": "object"
                        },
                        "default": []
                    },
                    "budgetUsd": {
                        "title": "Budget USD",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "number",
                        "description": "Optional cost budget for estimator modes.",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Alias for Max Targets/Maximum Records used by the Junipr actor baseline. When both are provided, actor-specific limits still apply.",
                        "default": 2
                    },
                    "includeReport": {
                        "title": "Include Report Artifacts",
                        "type": "boolean",
                        "description": "Write summary JSON and Markdown report artifacts to the key-value store.",
                        "default": true
                    },
                    "maxTargets": {
                        "title": "Max Targets",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum targets to process.",
                        "default": 2
                    },
                    "maxTextBytes": {
                        "title": "Max Text Bytes",
                        "minimum": 1000,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Maximum text bytes to analyze per target field.",
                        "default": 120000
                    },
                    "dryRun": {
                        "title": "Dry Run",
                        "type": "boolean",
                        "description": "Validate input and write a dry-run summary without PPE charges or dataset output.",
                        "default": false
                    },
                    "debug": {
                        "title": "Debug Logs",
                        "type": "boolean",
                        "description": "Enable debug logs.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
