# YAML Validator & Converter (`maximedupre/yaml-validator-converter`) Actor

Validate YAML, JSON, and TOML documents or public raw-file URLs. Convert valid files between formats, split YAML streams, and export syntax errors, line context, and converted content.

- **URL**: https://apify.com/maximedupre/yaml-validator-converter.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.55 / 1,000 processed documents

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### ✅ YAML Validator & Converter for config files

YAML Validator & Converter checks YAML, JSON, and TOML documents from pasted text or public raw-file URLs. Use it to validate config files, convert valid documents between formats, split multi-document YAML streams, and export clean rows with syntax errors, line context, converted content, and source details.

It is built for developers, automation teams, data teams, and anyone who needs repeatable config checks in Apify. You can run one document for a quick syntax check, or send a batch of pasted files and public URLs through the Apify API, schedules, webhooks, or exports.

The Actor auto-detects each input format. You do not need to label every task as YAML, JSON, or TOML before running it. Invalid syntax is saved as a normal output row with `isValid: false`, so batch runs can show every failure instead of hiding broken files.

### 🔍 What this Actor does

- Validates YAML, JSON, and TOML syntax.
- Converts valid documents to JSON, YAML, or TOML when the target format can represent the data.
- Accepts pasted document text, public raw-file URLs, or both in one batch.
- Auto-detects input format for mixed YAML, JSON, and TOML tasks.
- Splits YAML streams with `---` document markers into separate output rows.
- Reports parser errors with message, line, column, and nearby context when available.
- Keeps invalid documents in the dataset as validation results.
- Lets you stop after the first invalid document for strict automation gates.
- Can include the original submitted or fetched content when you need an audit trail.

This Actor checks syntax and converts structure. It does not validate Kubernetes, Docker Compose, Helm, Ansible, Cargo, or app-specific schemas. It also does not repair invalid documents or access private URLs. For private files, fetch them in your own environment and paste the content into `inputData`.

### 📥 Input

Add tasks in `tasks`. Each task can have a `name`, pasted `inputData`, a public HTTP or HTTPS `inputUrl`, or both. If both `inputData` and `inputUrl` are present, the pasted content is used for that task.

```json
{
	"tasks": [
		{
			"name": "inline-yaml",
			"inputData": "name: John Doe\nage: 30\nroles:\n  - admin\n  - editor"
		},
		{
			"name": "public-package-json",
			"inputUrl": "https://raw.githubusercontent.com/apify/crawlee/master/package.json"
		}
	],
	"operation": "convert",
	"outputFormat": "json",
	"jsonIndent": 2,
	"stopOnError": false,
	"includeOriginal": false
}
````

#### 🧾 Input fields

| Field | What it does |
| --- | --- |
| `tasks` | List of documents or public raw-file URLs to validate or convert. |
| `name` | Optional label you can use to match output rows back to your own batch. |
| `inputData` | Pasted YAML, JSON, or TOML text for one task. |
| `inputUrl` | Public HTTP or HTTPS URL of a raw YAML, JSON, or TOML file. |
| `operation` | Use `validate` to check syntax, or `convert` to also return converted content for valid documents. |
| `outputFormat` | Target format for converted documents: `json`, `yaml`, or `toml`. |
| `jsonIndent` | Number of spaces for converted JSON. Use `0` for compact JSON. |
| `stopOnError` | Stops the run after the first invalid document when you need fail-fast checks. |
| `includeOriginal` | Adds original document text to each output row for audit trails. |

### 📤 Output

Each dataset row represents one processed logical document. A single YAML stream can create more than one row when it contains multiple documents separated by `---`.

| Field | Description |
| --- | --- |
| `taskIndex` | 1-based position of the submitted task. |
| `taskName` | Optional task label from your input. |
| `documentIndex` | 1-based document number within the task. |
| `sourceUrl` | Public URL used for the task, or `null` for pasted content. |
| `inputPreview` | Short preview of the submitted or fetched document. |
| `inputFormat` | Auto-detected format: `yaml`, `json`, `toml`, or `unknown`. |
| `isValid` | Whether the document parsed successfully. |
| `errorMessage`, `errorLine`, `errorColumn`, `errorContext` | Parser-backed syntax details for invalid documents. |
| `outputFormat` | Conversion target for converted rows, or `null` for validate-only and invalid rows. |
| `convertedContent` | Converted document text when conversion succeeds. |
| `warnings` | Non-fatal notes, such as TOML conversion limits. |
| `originalContent` | Original document text when `includeOriginal` is enabled. |

#### 🧪 Output example

```json
{
	"taskIndex": 1,
	"taskName": "inline-yaml",
	"documentIndex": 1,
	"sourceUrl": null,
	"inputPreview": "name: John Doe age: 30 roles: - admin - editor",
	"inputFormat": "yaml",
	"isValid": true,
	"errorMessage": null,
	"errorLine": null,
	"errorColumn": null,
	"errorContext": null,
	"outputFormat": "json",
	"convertedContent": "{\n  \"name\": \"John Doe\",\n  \"age\": 30,\n  \"roles\": [\n    \"admin\",\n    \"editor\"\n  ]\n}",
	"warnings": [],
	"originalContent": null
}
```

Invalid documents are still output rows:

```json
{
	"taskIndex": 2,
	"taskName": "broken-yaml",
	"documentIndex": 1,
	"sourceUrl": null,
	"inputPreview": "name: [John age: 30",
	"inputFormat": "yaml",
	"isValid": false,
	"errorMessage": "Flow sequence in block collection must be sufficiently indented and end with a ]",
	"errorLine": 2,
	"errorColumn": 1,
	"errorContext": "1 | name: [John\n2 | age: 30",
	"outputFormat": null,
	"convertedContent": null,
	"warnings": ["Input could not be parsed as JSON, TOML, or YAML."],
	"originalContent": null
}
```

### 🚀 How to run it

1. Open the Actor input.
2. Add one or more items to **Documents and URLs**.
3. Keep **Validate syntax** for syntax checks, or choose **Convert valid documents**.
4. Pick the target output format when converting.
5. Run the Actor and open the dataset.

You can export results as JSON, CSV, Excel, XML, RSS, or HTML. You can also call the Actor from the Apify API, schedule repeat checks, use webhooks, or connect the dataset to another integration.

### 🔄 YAML, JSON, and TOML conversion notes

JSON output can represent objects, arrays, strings, numbers, booleans, and null values. YAML output can represent the parsed structure in YAML text. TOML output needs a top-level object, so arrays or scalar documents may validate successfully but return a warning instead of invented TOML.

The Actor does not expose a manual input-format selector. Mixed batches are expected: JSON-shaped input is parsed as JSON, TOML-shaped input is parsed as TOML, and remaining documents are parsed as YAML. If syntax is invalid, the row reports the parser-backed error details that are available.

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged once for each logical document that is processed and saved to the dataset. A YAML stream with multiple `---` document parts counts as multiple processed documents because each part gets its own output row.

URL fetch failures, empty tasks, malformed task objects, and other inputs that cannot be processed as documents are not saved as dataset rows and are not charged as processed documents.

### ⚠️ Limits and caveats

- Public URLs must point to raw text files that the Actor can fetch.
- Private files, intranet URLs, and authenticated URLs are not supported through `inputUrl`.
- The Actor validates syntax and structure, not app-specific schema rules.
- Invalid syntax rows may not always include both line and column if the parser cannot provide them.
- TOML cannot represent every JSON or YAML value, especially when the top-level value is not an object.

### ❓ FAQ

#### Can this validate Kubernetes YAML?

It can validate YAML syntax in Kubernetes manifests, including multi-document streams. It does not check Kubernetes resource schemas, required fields, cluster versions, or policy rules.

#### Can I process private config files?

Yes, if you paste the file content into `inputData`. The Actor does not log in to private repositories or fetch authenticated URLs.

#### Can I convert JSON to YAML or TOML to JSON?

Yes. Set `operation` to `convert` and choose `outputFormat`. Conversion returns content only when the parsed value can be represented in the target format.

#### What happens when one document is invalid?

By default, the Actor saves an invalid output row and continues with the rest of the batch. Set `stopOnError` to `true` when you want the run to stop after the first invalid document.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~yaml-validator-converter/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [XML JSON Converter ↗](https://apify.com/maximedupre/xml-json-converter) - Convert XML to JSON or JSON to XML from pasted data and public URLs.
- [URL to BibTeX Converter ↗](https://apify.com/maximedupre/url-to-bibtex-converter) - Turn article, DOI, PubMed, arXiv, and web page URLs into BibTeX citations.
- [Unicode Text Inspector ↗](https://apify.com/maximedupre/unicode-text-inspector) - Find hidden Unicode, zero-width spaces, bidi controls, and homoglyph issues in text.
- [Robots.txt Generator ↗](https://apify.com/maximedupre/robots-txt-generator) - Generate deployable robots.txt files for SEO, crawler control, and AI bot blocking.
- [SSL Certificate Checker ↗](https://apify.com/maximedupre/ssl-certificate-checker) - Check public HTTPS certificates, expiry, trust, hostname match, and TLS evidence.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `tasks` (type: `array`):

Add YAML, JSON, or TOML text, public raw-file URLs, or both.

## `operation` (type: `string`):

Choose whether to only check syntax or also convert valid documents.

## `outputFormat` (type: `string`):

Used when `Operation` is `Convert valid documents`.

## `jsonIndent` (type: `integer`):

Spaces to use when converted JSON is returned. Use 0 for compact JSON.

## `stopOnError` (type: `boolean`):

End the run after the first validation error when you use the Actor as a CI/CD gate.

## `includeOriginal` (type: `boolean`):

Add the submitted or fetched document text to each output row for audit trails.

## Actor input object example

```json
{
  "tasks": [
    {
      "name": "inline-yaml",
      "inputData": "name: John Doe\nage: 30\nroles:\n  - admin\n  - editor"
    },
    {
      "name": "inline-json",
      "inputData": "{\"service\":\"api\",\"enabled\":true,\"replicas\":2}"
    },
    {
      "name": "inline-toml",
      "inputData": "title = \"Example\"\n[owner]\nname = \"Ada\""
    },
    {
      "name": "yaml-stream",
      "inputData": "---\nkind: ConfigMap\nmetadata:\n  name: app-config\n---\nkind: Secret\nmetadata:\n  name: app-secret\n"
    },
    {
      "name": "public-config",
      "inputUrl": "https://raw.githubusercontent.com/apify/crawlee/master/package.json"
    }
  ],
  "operation": "validate",
  "outputFormat": "json",
  "jsonIndent": 2,
  "stopOnError": false,
  "includeOriginal": false
}
```

# Actor output Schema

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

Dataset of processed documents, with one item per logical document or YAML stream part.

# 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 = {
    "tasks": [
        {
            "name": "inline-yaml",
            "inputData": "name: John Doe\nage: 30\nroles:\n  - admin\n  - editor"
        },
        {
            "name": "inline-json",
            "inputData": "{\"service\":\"api\",\"enabled\":true,\"replicas\":2}"
        },
        {
            "name": "inline-toml",
            "inputData": "title = \"Example\"\n[owner]\nname = \"Ada\""
        },
        {
            "name": "yaml-stream",
            "inputData": "---\nkind: ConfigMap\nmetadata:\n  name: app-config\n---\nkind: Secret\nmetadata:\n  name: app-secret\n"
        },
        {
            "name": "public-config",
            "inputUrl": "https://raw.githubusercontent.com/apify/crawlee/master/package.json"
        }
    ],
    "operation": "validate",
    "outputFormat": "json",
    "jsonIndent": 2,
    "stopOnError": false,
    "includeOriginal": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/yaml-validator-converter").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 = {
    "tasks": [
        {
            "name": "inline-yaml",
            "inputData": """name: John Doe
age: 30
roles:
  - admin
  - editor""",
        },
        {
            "name": "inline-json",
            "inputData": "{\"service\":\"api\",\"enabled\":true,\"replicas\":2}",
        },
        {
            "name": "inline-toml",
            "inputData": """title = \"Example\"
[owner]
name = \"Ada\"""",
        },
        {
            "name": "yaml-stream",
            "inputData": """---
kind: ConfigMap
metadata:
  name: app-config
---
kind: Secret
metadata:
  name: app-secret
""",
        },
        {
            "name": "public-config",
            "inputUrl": "https://raw.githubusercontent.com/apify/crawlee/master/package.json",
        },
    ],
    "operation": "validate",
    "outputFormat": "json",
    "jsonIndent": 2,
    "stopOnError": False,
    "includeOriginal": False,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/yaml-validator-converter").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 '{
  "tasks": [
    {
      "name": "inline-yaml",
      "inputData": "name: John Doe\\nage: 30\\nroles:\\n  - admin\\n  - editor"
    },
    {
      "name": "inline-json",
      "inputData": "{\\"service\\":\\"api\\",\\"enabled\\":true,\\"replicas\\":2}"
    },
    {
      "name": "inline-toml",
      "inputData": "title = \\"Example\\"\\n[owner]\\nname = \\"Ada\\""
    },
    {
      "name": "yaml-stream",
      "inputData": "---\\nkind: ConfigMap\\nmetadata:\\n  name: app-config\\n---\\nkind: Secret\\nmetadata:\\n  name: app-secret\\n"
    },
    {
      "name": "public-config",
      "inputUrl": "https://raw.githubusercontent.com/apify/crawlee/master/package.json"
    }
  ],
  "operation": "validate",
  "outputFormat": "json",
  "jsonIndent": 2,
  "stopOnError": false,
  "includeOriginal": false
}' |
apify call maximedupre/yaml-validator-converter --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YAML Validator & Converter",
        "description": "Validate YAML, JSON, and TOML documents or public raw-file URLs. Convert valid files between formats, split YAML streams, and export syntax errors, line context, and converted content.",
        "version": "0.0",
        "x-build-id": "tWgy5JgxBOFw4lVcJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~yaml-validator-converter/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-yaml-validator-converter",
                "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/maximedupre~yaml-validator-converter/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-yaml-validator-converter",
                "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/maximedupre~yaml-validator-converter/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-yaml-validator-converter",
                "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": [
                    "tasks"
                ],
                "properties": {
                    "tasks": {
                        "title": "Documents and URLs",
                        "type": "array",
                        "description": "Add YAML, JSON, or TOML text, public raw-file URLs, or both."
                    },
                    "operation": {
                        "title": "Operation",
                        "enum": [
                            "validate",
                            "convert"
                        ],
                        "type": "string",
                        "description": "Choose whether to only check syntax or also convert valid documents.",
                        "default": "validate"
                    },
                    "outputFormat": {
                        "title": "Output format",
                        "enum": [
                            "json",
                            "yaml",
                            "toml"
                        ],
                        "type": "string",
                        "description": "Used when `Operation` is `Convert valid documents`.",
                        "default": "json"
                    },
                    "jsonIndent": {
                        "title": "JSON indentation",
                        "minimum": 0,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Spaces to use when converted JSON is returned. Use 0 for compact JSON.",
                        "default": 2
                    },
                    "stopOnError": {
                        "title": "Stop on first invalid document",
                        "type": "boolean",
                        "description": "End the run after the first validation error when you use the Actor as a CI/CD gate.",
                        "default": false
                    },
                    "includeOriginal": {
                        "title": "Include original content",
                        "type": "boolean",
                        "description": "Add the submitted or fetched document text to each output row for audit trails.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
