# Dataset QA Auditor (`junipr/dataset-qa-auditor`) Actor

Validate Apify dataset rows for schema drift, null spikes, duplicate keys, type mismatches, and delivery-readiness issues. Outputs row-level QA results plus a summary report.

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

## Pricing

from $3.90 / 1,000 item checkeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

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

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

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

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

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

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

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

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


# README

## Dataset QA Auditor

Validate Apify datasets for schema drift, null spikes, duplicate rows, type errors, and delivery readiness before you hand data to a client, importer, automation, or downstream model.

### What This Actor Does

Dataset QA Auditor checks either inline records or an Apify dataset sample and emits row-level QA results. It is built for the common failure modes that make scraped or transformed datasets painful to deliver:

- Duplicate business keys such as repeated product IDs, lead IDs, or URLs.
- Missing fields, empty fields, and null spikes across a dataset.
- Type drift such as a numeric field becoming a string.
- Semantic field validation for URLs, emails, dates, integers, arrays, objects, booleans, and nulls.
- Unexpected fields when strict schema checks are enabled.
- A Markdown and JSON summary report in the key-value store.

### What This Actor Does Not Do

- It does not enrich, scrape, or collect new data.
- It does not validate sensitive personal data or provide legal, medical, or financial advice.
- It does not guarantee a dataset is compliant with any regulation.
- It does not automatically fix rows; it tells you exactly what should be fixed before delivery.

### Best Use Cases

- QA a scraper output before sending it to a customer.
- Detect schema drift after changing selectors or parsers.
- Check lead lists, product catalogs, app-review exports, job datasets, or monitoring feeds before import.
- Generate a concise QA handoff report for a dataset delivery workflow.
- Run a scheduled check against a stable Apify dataset sample.

### Input Fields

- `records`: Inline object rows to audit. The default sample intentionally contains duplicate, null, and type issues so the zero-config run demonstrates useful output.
- `datasetId`: Optional Apify dataset ID. When present, the actor reads rows from that dataset instead of `records`.
- `expectedSchema`: Field-to-type map. Supported types are `string`, `number`, `integer`, `boolean`, `object`, `array`, `null`, `date`, `url`, and `email`.
- `keyFields`: One or more fields used to detect duplicate rows.
- `strictSchema`: Treat missing and unexpected fields as stronger readiness issues.
- `nullSpikeThreshold`: Warn when a field is null or missing in at least this share of checked rows.
- `maxItems`: Maximum records to check. The hard cap is 10,000 and the default is 50.
- `includeReport`: Store Markdown and JSON reports in the default key-value store.
- `debug`: Enable extra troubleshooting logs.

### Example Input

```json
{
  "records": [
    {
      "id": "lead-001",
      "company": "Northwind Studio",
      "website": "https://example.com",
      "email": "hello@example.com",
      "employeeCount": 12,
      "country": "US"
    },
    {
      "id": "lead-002",
      "company": "Contoso Works",
      "website": "https://example.org",
      "email": null,
      "employeeCount": "27",
      "country": "US"
    }
  ],
  "expectedSchema": {
    "id": "string",
    "company": "string",
    "website": "url",
    "email": "email",
    "employeeCount": "integer",
    "country": "string"
  },
  "keyFields": ["id"],
  "maxItems": 50,
  "includeReport": true
}
````

### Output Fields

Each dataset item represents one checked row:

- `auditId`: Stable hash for the checked row.
- `sourceType` and `sourceId`: Whether the row came from inline input or an Apify dataset.
- `rowIndex`: Zero-based row index in the checked input.
- `recordKey`: Duplicate-detection key assembled from `keyFields`.
- `status`: `pass`, `warn`, or `fail`.
- `severity`: Highest issue severity on the row.
- `issues`: Detailed issue list with code, field, severity, and message.
- `duplicateKey`: Duplicate key value when this row repeats an earlier row.
- `missingFields`, `extraFields`, `nullFields`, and `typeMismatches`: Structured issue details.
- `recommendation`: Short next step for the row.

The key-value store also contains:

- `QA_REPORT.md`: Human-readable summary.
- `QA_SUMMARY.json`: Machine-readable summary.

### Example Output

```json
{
  "auditId": "da3735af7de3eca7",
  "sourceType": "inline",
  "sourceId": "inline-records",
  "rowIndex": 1,
  "recordKey": "lead-002",
  "status": "fail",
  "severity": "high",
  "issueCount": 2,
  "issues": [
    {
      "code": "missing-field",
      "severity": "medium",
      "field": "email",
      "message": "Expected field \"email\" is missing or empty."
    },
    {
      "code": "type-mismatch",
      "severity": "high",
      "field": "employeeCount",
      "message": "Expected integer, received string."
    }
  ],
  "duplicateKey": null,
  "missingFields": ["email"],
  "extraFields": [],
  "nullFields": ["email"],
  "typeMismatches": [
    {
      "field": "employeeCount",
      "expected": "integer",
      "actual": "string",
      "valuePreview": "27"
    }
  ],
  "fieldCount": 6,
  "checkedAt": "2026-07-02T00:00:00.000Z",
  "recommendation": "Normalize mismatched field types before delivery."
}
```

### Pricing And Events

This actor uses pay-per-event pricing with the U2 data utility template:

- `actor-start`: $0.005 per run for setup and input preparation.
- `item-checked`: $0.0039 per checked record, or $3.90 per 1,000 records.
- `report-generated`: $0.02 when a Markdown/JSON report is generated.

Platform usage pass-through is intentionally off because this is a bounded, lightweight utility. Use `maxItems` to control cost and start with a small sample before checking larger datasets.

### Cost-Control Tips

- Start with the default sample or `maxItems` between 10 and 100.
- Use `datasetId` with a small cap before auditing a full production dataset.
- Keep `includeReport` on for normal runs; turn it off only when you need row-level output without a summary artifact.
- Use stable `keyFields` such as `id`, `url`, `sku`, or a composite key to avoid noisy duplicate results.

### Scheduling Examples

- Run after every scraper deployment to catch schema drift.
- Schedule daily against a small recent sample from a production dataset.
- Trigger before exporting a dataset to a client, CRM, spreadsheet, warehouse, or RAG pipeline.

### Public Task Examples

This actor includes five prepared task concepts:

- Lead list delivery-readiness check.
- Scraper output schema-drift check.
- Marketplace catalog null-spike check.
- Apify dataset duplicate-key check.
- Client handoff QA summary.

### FAQ

#### Can this audit private Apify datasets?

Yes, when the run has access to the dataset ID through your Apify account. Keep the sample size low until the schema is configured correctly.

#### What happens if I do not provide an expected schema?

The actor infers a schema from the first non-null values in the checked records. For production QA, a configured `expectedSchema` is better because it catches drift against your intended output.

#### Does it mutate or clean my dataset?

No. It only reads input rows, pushes QA result rows, and writes summary artifacts.

#### Are diagnostics billed as dataset rows?

No. Row-level QA output is billed via `item-checked`. Summary diagnostics are written to the key-value store, not as extra default dataset rows.

### Troubleshooting

- `No records to audit`: Provide `records` or a `datasetId` that contains object rows.
- Many `invalid-key` issues: Set `keyFields` to fields that actually exist and are populated.
- Too many type mismatches: Check whether your `expectedSchema` type names match the supported type list.
- Null spikes are too noisy: Raise `nullSpikeThreshold`, or narrow the expected schema to fields required for delivery.

### Limitations

- Only top-level fields are checked in this first version.
- Semantic checks are intentionally conservative for URLs, emails, and dates.
- Large datasets should be sampled first because every checked row is billable.
- This is a QA signal, not a compliance guarantee.

### Source And Safety Notes

This actor does not scrape websites or enrich records. It processes user-provided rows or datasets that the user already has permission to access. Do not upload sensitive personal data unless you are authorized to process it in Apify.

### Changelog

- `1.0.0`: Initial production build with duplicate-key detection, schema checks, null-spike reporting, KVS summaries, PPE billing, examples, and fixture tests.

### Premium local completion scope

This actor is prepared for local ChatGPT review as a premium, honestly scoped Store candidate. It processes user-supplied fixtures, records, snapshots, schemas, URLs, or exported source data with strict caps and deterministic logic before any live Apify replay.

It does not perform live Apify Store publication, live Store icon upload, live public task creation, or live pricing changes in this local package. Cloud replay remains a separate step. The local implementation is scoped to: Validate Apify datasets for schema drift, null spikes, duplicate rows, type errors, and delivery readiness.

Use the default input first. It is intentionally tiny and designed to complete quickly while still producing dataset rows, schema-validation evidence, billing-guard proof, and report artifacts.

# Actor input Schema

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

Records to audit directly. Leave this default sample in place for a tiny zero-config run, or replace it with rows from your dataset.

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

Optional Apify dataset ID to audit. If provided, rows are read from that dataset instead of Inline Records.

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

Optional field-to-type map. Supported types: string, number, integer, boolean, object, array, null, date, url, email. Leave empty to infer from the first non-null values.

## `keyFields` (type: `array`):

Fields used to identify duplicates. Multiple fields are combined into one stable key.

## `strictSchema` (type: `boolean`):

Treat missing and unexpected fields as stronger delivery-readiness issues.

## `nullSpikeThreshold` (type: `number`):

Warn when a field is null or missing in at least this share of checked rows.

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

Maximum number of records to check. Defaults low so the sample run finishes quickly.

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

Store a Markdown and JSON QA summary in the default key-value store.

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

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

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

Enable additional logs for troubleshooting schema decisions.

## Actor input object example

```json
{
  "records": [
    {
      "id": "lead-001",
      "company": "Northwind Studio",
      "website": "https://example.com",
      "email": "hello@example.com",
      "employeeCount": 12,
      "country": "US"
    },
    {
      "id": "lead-002",
      "company": "Contoso Works",
      "website": "https://example.org",
      "email": null,
      "employeeCount": "27",
      "country": "US"
    },
    {
      "id": "lead-001",
      "company": "Northwind Studio Duplicate",
      "website": "not-a-url",
      "email": "sales@example.com",
      "country": null
    }
  ],
  "datasetId": "",
  "expectedSchema": {
    "id": "string",
    "company": "string",
    "website": "url",
    "email": "email",
    "employeeCount": "integer",
    "country": "string"
  },
  "keyFields": [
    "id"
  ],
  "strictSchema": false,
  "nullSpikeThreshold": 0.4,
  "maxItems": 50,
  "includeReport": true,
  "dryRun": false,
  "debug": false
}
```

# Actor output Schema

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

Each checked record with schema, duplicate, null, and type-readiness findings.

## `summaryReport` (type: `string`):

Markdown report stored in the default key-value store.

## `summaryJson` (type: `string`):

Machine-readable QA summary stored in the default key-value store.

# 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/dataset-qa-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/dataset-qa-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/dataset-qa-auditor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Dataset QA Auditor",
        "description": "Validate Apify dataset rows for schema drift, null spikes, duplicate keys, type mismatches, and delivery-readiness issues. Outputs row-level QA results plus a summary report.",
        "version": "1.0",
        "x-build-id": "tx1aENN8adgRr5kJe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/junipr~dataset-qa-auditor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-junipr-dataset-qa-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~dataset-qa-auditor/runs": {
            "post": {
                "operationId": "runs-sync-junipr-dataset-qa-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~dataset-qa-auditor/run-sync": {
            "post": {
                "operationId": "run-sync-junipr-dataset-qa-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": {
                    "records": {
                        "title": "Inline Records",
                        "type": "array",
                        "description": "Records to audit directly. Leave this default sample in place for a tiny zero-config run, or replace it with rows from your dataset.",
                        "items": {
                            "type": "object"
                        },
                        "default": [
                            {
                                "id": "lead-001",
                                "company": "Northwind Studio",
                                "website": "https://example.com",
                                "email": "hello@example.com",
                                "employeeCount": 12,
                                "country": "US"
                            },
                            {
                                "id": "lead-002",
                                "company": "Contoso Works",
                                "website": "https://example.org",
                                "email": null,
                                "employeeCount": "27",
                                "country": "US"
                            },
                            {
                                "id": "lead-001",
                                "company": "Northwind Studio Duplicate",
                                "website": "not-a-url",
                                "email": "sales@example.com",
                                "country": null
                            }
                        ]
                    },
                    "datasetId": {
                        "title": "Apify Dataset ID",
                        "type": "string",
                        "description": "Optional Apify dataset ID to audit. If provided, rows are read from that dataset instead of Inline Records.",
                        "default": ""
                    },
                    "expectedSchema": {
                        "title": "Expected Schema",
                        "type": "object",
                        "description": "Optional field-to-type map. Supported types: string, number, integer, boolean, object, array, null, date, url, email. Leave empty to infer from the first non-null values.",
                        "default": {
                            "id": "string",
                            "company": "string",
                            "website": "url",
                            "email": "email",
                            "employeeCount": "integer",
                            "country": "string"
                        }
                    },
                    "keyFields": {
                        "title": "Duplicate Key Fields",
                        "type": "array",
                        "description": "Fields used to identify duplicates. Multiple fields are combined into one stable key.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "id"
                        ]
                    },
                    "strictSchema": {
                        "title": "Strict Schema",
                        "type": "boolean",
                        "description": "Treat missing and unexpected fields as stronger delivery-readiness issues.",
                        "default": false
                    },
                    "nullSpikeThreshold": {
                        "title": "Null Spike Threshold",
                        "minimum": 0,
                        "maximum": 1,
                        "type": "number",
                        "description": "Warn when a field is null or missing in at least this share of checked rows.",
                        "default": 0.4
                    },
                    "maxItems": {
                        "title": "Maximum Records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of records to check. Defaults low so the sample run finishes quickly.",
                        "default": 50
                    },
                    "includeReport": {
                        "title": "Generate Summary Report",
                        "type": "boolean",
                        "description": "Store a Markdown and JSON QA summary in the default key-value store.",
                        "default": true
                    },
                    "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 Logging",
                        "type": "boolean",
                        "description": "Enable additional logs for troubleshooting schema decisions.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```