# Dataset Quality Gate - Schema & Data QA (`jy-labs/dataset-quality-gate`) Actor

Validate Apify Datasets by pasted items, Dataset ID, or Run ID before delivery, automation, or AI/RAG ingestion. Catch schema drift, missing fields, duplicates, and bad URLs/emails/dates.

- **URL**: https://apify.com/jy-labs/dataset-quality-gate.md
- **Developed by:** [Juyeop Park](https://apify.com/jy-labs) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## Dataset Quality Gate - Schema & Data QA for Apify

**Stop bad JSON data before it reaches customers, automations, or AI/RAG pipelines.**

Dataset Quality Gate validates Apify Dataset items and turns them into a clear pass/fail quality report. You can now use it in three ways:

1. Paste JSON items directly.
2. Provide an **Apify Dataset ID** and let the Actor fetch the items.
3. Provide an **Apify Run ID** and let the Actor validate that run's default dataset.

It checks required fields, schema/type drift, duplicate IDs or URLs, URL/email/date formats, and field-level profiles — without external websites, proxies, cookies, AI tokens, or third-party APIs.

### Best for

- **Scraped data delivery QA** — catch missing URLs, empty titles, malformed emails, bad dates, and duplicate records before a customer sees them.
- **AI/RAG ingestion guardrails** — reject malformed records before embeddings, retrieval, or agent workflows consume them.
- **Apify workflow monitoring** — validate the default dataset from a finished Actor run by pasting only the `runId`.
- **Schema drift detection** — confirm that fields remain strings, numbers, booleans, arrays, objects, or nulls as expected.
- **Automation fail gates** — stop CI/CD, webhook, or scheduled pipelines when data quality falls below the expected contract.

### Why use this instead of manual inspection?

Manual spot checks miss silent failures: one upstream selector change can leave hundreds of records with missing URLs, empty titles, duplicated IDs, or type changes that only break later. Dataset Quality Gate makes those checks repeatable and machine-readable while still producing a Markdown report for human review.

### Input modes

#### 1. Validate by Run ID — easiest for Apify workflows

Use this when you want to check the output of a previous Actor run.

```json
{
  "reportName": "Daily scraper QA",
  "runId": "YOUR_ACTOR_RUN_ID",
  "maxItems": 1000,
  "validateAllItems": false,
  "requiredFields": ["id", "url", "title"],
  "uniqueFields": ["url"],
  "formatRules": { "url": "url" }
}
````

The Actor resolves the run's default dataset automatically.

#### 2. Validate by Dataset ID

Use this when you already know the dataset to inspect.

```json
{
  "reportName": "Customer delivery dataset QA",
  "datasetId": "YOUR_DATASET_ID",
  "maxItems": 5000,
  "validateAllItems": true,
  "requiredFields": ["id", "url", "email"],
  "uniqueFields": ["id", "url"],
  "formatRules": {
    "url": "url",
    "email": "email"
  }
}
```

`validateAllItems=true` paginates through the dataset until it is exhausted or `maxItems` is reached.

#### 3. Validate pasted JSON items

Use this for a quick manual sample or local testing.

```json
{
  "reportName": "Daily lead dataset QA",
  "items": [
    {
      "id": "lead-1",
      "url": "https://example.com/company-a",
      "email": "owner@example.com",
      "publishedAt": "2026-05-20"
    },
    {
      "id": "lead-2",
      "url": "https://example.com/company-b",
      "email": "sales@example.com",
      "publishedAt": "2026-05-21"
    }
  ],
  "requiredFields": ["id", "url", "email"],
  "expectedSchema": {
    "id": "string",
    "url": "string",
    "email": "string",
    "publishedAt": "string"
  },
  "uniqueFields": ["id", "url"],
  "formatRules": {
    "url": "url",
    "email": "email",
    "publishedAt": "date"
  }
}
```

If `datasetId` or `runId` is provided, the external source is used and pasted `items` are ignored.

### Sampling and full-dataset controls

- `maxItems` — safety cap for how many dataset records to check. Default: `1000`, maximum: `50000`.
- `validateAllItems=false` — fetch one sample page using `maxItems`.
- `validateAllItems=true` — paginate until the dataset is exhausted or `maxItems` is reached.
- `itemOffset` — skip records before validation.
- `itemOrder=first` — validate the earliest stored items first.
- `itemOrder=last` — validate the latest stored items first.

The output includes source metadata such as source type, dataset ID, run ID, checked item count, available item count, and whether the source was truncated by the configured limit.

### What it checks

- Required field presence and non-empty values
- Expected top-level JSON types: `string`, `number`, `boolean`, `object`, `array`, `null`
- Duplicate values for configured unique fields
- URL, email, and date format checks
- Field-level profiling:
  - present / missing counts
  - null counts
  - empty string counts
  - type distribution
  - sample values

Supported `expectedSchema` values: `string`, `number`, `boolean`, `object`, `array`, `null`.

Supported `formatRules` values: `url`, `email`, `date`.

Unsupported rule values fail fast with a clear input error.

### Run modes

#### 1. Report-only mode — default

Set `failRunOnError=false`.

The Actor writes the summary dataset item plus full `OUTPUT` and `REPORT` artifacts. The Actor run can still succeed even when the quality report status is `fail`.

Use this for audits, dashboards, scheduled QA reports, manual review, and exploratory checks.

#### 2. Fail-gate mode

Set `failRunOnError=true`.

The Actor writes the full JSON and Markdown report first, then fails the run if validation errors are found.

Use this for CI/CD gates, webhook pipelines, production automations, and any workflow where bad data must stop the next step.

### Output

The Actor pushes one summary item to the default dataset:

```json
{
  "type": "dataset_quality_report",
  "status": "fail",
  "passed": false,
  "reportName": "Daily lead dataset QA",
  "totalItems": 1000,
  "fieldCount": 12,
  "totalIssues": 5,
  "errorCount": 5,
  "warningCount": 0,
  "issueCountsByCode": {
    "REQUIRED_FIELD_MISSING": 1,
    "DUPLICATE_UNIQUE_FIELD": 1,
    "FORMAT_INVALID": 3
  },
  "sourceType": "run",
  "sourceDatasetId": "abc123",
  "sourceRunId": "run123",
  "sourceLoadedItems": 1000,
  "sourceTotalAvailable": 2500,
  "sourceTruncated": true
}
```

It also stores full artifacts in the default key-value store:

- `OUTPUT` — full JSON report including all issues, field profiles, and source metadata
- `REPORT` — Markdown report for human review and sharing

### Common workflow recipes

#### Customer delivery QA

```json
{
  "runId": "YOUR_SCRAPER_RUN_ID",
  "requiredFields": ["id", "url", "title"],
  "uniqueFields": ["id", "url"],
  "formatRules": { "url": "url" }
}
```

#### AI/RAG ingestion QA

```json
{
  "datasetId": "YOUR_DATASET_ID",
  "requiredFields": ["url", "title", "text"],
  "expectedSchema": {
    "url": "string",
    "title": "string",
    "text": "string"
  },
  "uniqueFields": ["url"],
  "formatRules": { "url": "url" }
}
```

#### Production fail gate

```json
{
  "runId": "YOUR_UPSTREAM_RUN_ID",
  "failRunOnError": true,
  "requiredFields": ["id", "url", "email"],
  "uniqueFields": ["id", "email"],
  "formatRules": { "url": "url", "email": "email" }
}
```

### Pricing

This Actor is configured for **pay per event (PPE)** pricing.

- **Quality report**: `$0.05` per completed quality report
- **Actor start**: `$0.005` per run start

The pricing is intentionally simple and predictable: you pay for one completed dataset QA report, not for external API calls or proxy usage. The Actor does not call AI APIs or third-party scraping services.

### Limitations

- Validation is top-level JSON field validation only.
- Nested object schema validation is not included yet.
- `runId` and `datasetId` must be accessible from the account running the Actor.
- `validateAllItems=true` is still capped by `maxItems` to avoid runaway memory/time usage.
- It does not perform semantic validation or AI-based judgement.
- Future expansion candidates: Dataset Diff, PII Scanner, RAG Readiness Checker, and webhook/Slack failure notifications.

### FAQ

#### Does it use proxies, cookies, or third-party APIs?

No. It validates JSON items and can read Apify Dataset/Run data available to the running account. It does not scrape websites, use proxies, or call external AI APIs.

#### Does a failed quality gate still produce a report?

Yes. In fail-gate mode, the Actor writes `OUTPUT` and `REPORT` first, then fails the run so your automation can stop while diagnostics remain available.

#### What should I use as `uniqueFields`?

Good candidates are stable identifiers such as `id`, `url`, `sku`, `email`, `profileUrl`, `productUrl`, or any field that should appear only once per dataset.

#### Is this only for AI/RAG workflows?

No. AI/RAG ingestion is a strong use case, but the Actor is equally useful for customer data delivery, lead lists, product datasets, SEO datasets, scheduled audits, and webhook-based automation.

### Local development

```bash
npm install
npm test
npm run local
```

Apify local runtime smoke:

```bash
apify run --purge --input-file INPUT.pass.example.json
apify run --purge --input-file INPUT.fail.example.json
apify run --purge --input-file INPUT.fail-gate.example.json
```

# Actor input Schema

## `reportName` (type: `string`):

Name shown in the generated QA report. Use a customer, Actor, dataset, or pipeline name.

## `datasetId` (type: `string`):

Optional. Paste an Apify Dataset ID to fetch and validate its items automatically. Leave empty when using Run ID or pasted items.

## `runId` (type: `string`):

Optional. Paste an Actor run ID and this Actor will validate that run's default dataset. Leave empty when using Dataset ID or pasted items.

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

Safety cap for fetched dataset/run items. Default is 1000, maximum is 50000. Use with validateAllItems for full-dataset pagination up to this cap.

## `validateAllItems` (type: `boolean`):

When true, fetch multiple pages until the dataset is exhausted or maxItems is reached. When false, only one sample page is checked.

## `itemOffset` (type: `integer`):

Number of dataset items to skip before validation. Use this to inspect a later sample page.

## `itemOrder` (type: `string`):

Validate the first stored items or the latest stored items first.

## `failRunOnError` (type: `boolean`):

Turn this on for CI/CD, webhooks, or scheduled automations where bad data must stop the next step. Leave off for audit/report-only mode.

## `items` (type: `array`):

Optional fallback for pasted/exported JSON items. If datasetId or runId is provided, this manual sample is ignored.

## `requiredFields` (type: `array`):

Field names that must exist and be non-empty in every item, such as id, url, title, price, or email.

## `expectedSchema` (type: `object`):

Map field names to expected top-level JSON types. Supported values: string, number, boolean, object, array, null.

## `uniqueFields` (type: `array`):

Field names where duplicate non-empty values should fail the quality gate, such as id, url, sku, email, or profileUrl.

## `formatRules` (type: `object`):

Map field names to format checks. Supported values: url, email, date.

## Actor input object example

```json
{
  "reportName": "Sample dataset quality report",
  "maxItems": 1000,
  "validateAllItems": false,
  "itemOffset": 0,
  "itemOrder": "first",
  "failRunOnError": false,
  "items": [
    {
      "id": "item-1",
      "url": "https://example.com/a",
      "email": "owner@example.com"
    },
    {
      "id": "item-2",
      "url": "https://example.com/b",
      "email": "second@example.com"
    }
  ],
  "requiredFields": [
    "id",
    "url"
  ],
  "expectedSchema": {
    "id": "string",
    "url": "string",
    "email": "string"
  },
  "uniqueFields": [
    "id"
  ],
  "formatRules": {
    "url": "url",
    "email": "email"
  }
}
```

# Actor output Schema

## `summaryDataset` (type: `string`):

No description

## `jsonReport` (type: `string`):

No description

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "reportName": "Sample dataset quality report",
    "maxItems": 1000,
    "validateAllItems": false,
    "itemOffset": 0,
    "itemOrder": "first",
    "failRunOnError": false,
    "items": [
        {
            "id": "item-1",
            "url": "https://example.com/a",
            "email": "owner@example.com"
        },
        {
            "id": "item-2",
            "url": "https://example.com/b",
            "email": "second@example.com"
        }
    ],
    "requiredFields": [
        "id",
        "url"
    ],
    "expectedSchema": {
        "id": "string",
        "url": "string",
        "email": "string"
    },
    "uniqueFields": [
        "id"
    ],
    "formatRules": {
        "url": "url",
        "email": "email"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jy-labs/dataset-quality-gate").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 = {
    "reportName": "Sample dataset quality report",
    "maxItems": 1000,
    "validateAllItems": False,
    "itemOffset": 0,
    "itemOrder": "first",
    "failRunOnError": False,
    "items": [
        {
            "id": "item-1",
            "url": "https://example.com/a",
            "email": "owner@example.com",
        },
        {
            "id": "item-2",
            "url": "https://example.com/b",
            "email": "second@example.com",
        },
    ],
    "requiredFields": [
        "id",
        "url",
    ],
    "expectedSchema": {
        "id": "string",
        "url": "string",
        "email": "string",
    },
    "uniqueFields": ["id"],
    "formatRules": {
        "url": "url",
        "email": "email",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("jy-labs/dataset-quality-gate").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 '{
  "reportName": "Sample dataset quality report",
  "maxItems": 1000,
  "validateAllItems": false,
  "itemOffset": 0,
  "itemOrder": "first",
  "failRunOnError": false,
  "items": [
    {
      "id": "item-1",
      "url": "https://example.com/a",
      "email": "owner@example.com"
    },
    {
      "id": "item-2",
      "url": "https://example.com/b",
      "email": "second@example.com"
    }
  ],
  "requiredFields": [
    "id",
    "url"
  ],
  "expectedSchema": {
    "id": "string",
    "url": "string",
    "email": "string"
  },
  "uniqueFields": [
    "id"
  ],
  "formatRules": {
    "url": "url",
    "email": "email"
  }
}' |
apify call jy-labs/dataset-quality-gate --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=jy-labs/dataset-quality-gate",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dataset Quality Gate - Schema & Data QA",
        "description": "Validate Apify Datasets by pasted items, Dataset ID, or Run ID before delivery, automation, or AI/RAG ingestion. Catch schema drift, missing fields, duplicates, and bad URLs/emails/dates.",
        "version": "0.3",
        "x-build-id": "N0rzlJlvaH6hLn55t"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jy-labs~dataset-quality-gate/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jy-labs-dataset-quality-gate",
                "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/jy-labs~dataset-quality-gate/runs": {
            "post": {
                "operationId": "runs-sync-jy-labs-dataset-quality-gate",
                "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/jy-labs~dataset-quality-gate/run-sync": {
            "post": {
                "operationId": "run-sync-jy-labs-dataset-quality-gate",
                "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": {
                    "reportName": {
                        "title": "Report name",
                        "type": "string",
                        "description": "Name shown in the generated QA report. Use a customer, Actor, dataset, or pipeline name."
                    },
                    "datasetId": {
                        "title": "Apify Dataset ID to validate",
                        "type": "string",
                        "description": "Optional. Paste an Apify Dataset ID to fetch and validate its items automatically. Leave empty when using Run ID or pasted items."
                    },
                    "runId": {
                        "title": "Apify Run ID to validate",
                        "type": "string",
                        "description": "Optional. Paste an Actor run ID and this Actor will validate that run's default dataset. Leave empty when using Dataset ID or pasted items."
                    },
                    "maxItems": {
                        "title": "Maximum items to check",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Safety cap for fetched dataset/run items. Default is 1000, maximum is 50000. Use with validateAllItems for full-dataset pagination up to this cap.",
                        "default": 1000
                    },
                    "validateAllItems": {
                        "title": "Paginate through the dataset",
                        "type": "boolean",
                        "description": "When true, fetch multiple pages until the dataset is exhausted or maxItems is reached. When false, only one sample page is checked.",
                        "default": false
                    },
                    "itemOffset": {
                        "title": "Item offset",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of dataset items to skip before validation. Use this to inspect a later sample page.",
                        "default": 0
                    },
                    "itemOrder": {
                        "title": "Item order",
                        "enum": [
                            "first",
                            "last"
                        ],
                        "type": "string",
                        "description": "Validate the first stored items or the latest stored items first.",
                        "default": "first"
                    },
                    "failRunOnError": {
                        "title": "Fail the run when the gate fails",
                        "type": "boolean",
                        "description": "Turn this on for CI/CD, webhooks, or scheduled automations where bad data must stop the next step. Leave off for audit/report-only mode.",
                        "default": false
                    },
                    "items": {
                        "title": "Dataset items to validate manually",
                        "type": "array",
                        "description": "Optional fallback for pasted/exported JSON items. If datasetId or runId is provided, this manual sample is ignored.",
                        "items": {
                            "type": "object",
                            "additionalProperties": true
                        }
                    },
                    "requiredFields": {
                        "title": "Fields that must be present",
                        "type": "array",
                        "description": "Field names that must exist and be non-empty in every item, such as id, url, title, price, or email.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "expectedSchema": {
                        "title": "Expected field types",
                        "type": "object",
                        "description": "Map field names to expected top-level JSON types. Supported values: string, number, boolean, object, array, null.",
                        "additionalProperties": true
                    },
                    "uniqueFields": {
                        "title": "Fields that must be unique",
                        "type": "array",
                        "description": "Field names where duplicate non-empty values should fail the quality gate, such as id, url, sku, email, or profileUrl.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "formatRules": {
                        "title": "URL, email, and date checks",
                        "type": "object",
                        "description": "Map field names to format checks. Supported values: url, email, date.",
                        "additionalProperties": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```