# Storage Tools (`marco.gullo/storage-tools`)

Query storages on the Apify platform.

- **URL**: https://beta-securitybyobscurity.apify.com/marco.gullo/storage-tools.md
- **Developed by:** [Marco Gullo](https://beta-securitybyobscurity.apify.com/marco.gullo) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 2 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

# README

## Storage Tools

Query storages on the Apify platform.

# Actor input Schema

## `datasetIds` (type: `array`):

The IDs or the username~store-name of the datasets to query.

## `keyValueStoreIds` (type: `array`):

The IDs or the username~store-name of the key-value stores to query.

## `previousRunId` (type: `string`):

Use the output of a previous run.

## `storageKinds` (type: `array`):

The type of storage to query on the account.

## `includeUnnamed` (type: `boolean`):

Whether to include storages without a name.

## `outputFields` (type: `array`):

The fields to include in the output.

## `sortOutputBy` (type: `string`):

The key to sort the output by.

## `sortOutputOrder` (type: `string`):

The order to sort the output by.

## `filterNameByRegex` (type: `string`):

A regular expression to filter the storages by their names.

## `filterUserId` (type: `array`):

The user ID to filter the storages by.

## `filterUsernameByRegex` (type: `string`):

A regular expression to filter the storages by their usernames.

## `filterCreatedBefore` (type: `string`):

The date to filter the storages by their creation date in format YYYY-MM-DD or {number} {unit}.

## `filterCreatedAfter` (type: `string`):

The date to filter the storages by their creation date in format YYYY-MM-DD or {number} {unit}.

## `filterModifiedBefore` (type: `string`):

The date to filter the storages by their last modification date in format YYYY-MM-DD or {number} {unit}.

## `filterModifiedAfter` (type: `string`):

The date to filter the storages by their last modification date in format YYYY-MM-DD or {number} {unit}.

## `filterAccessedBefore` (type: `string`):

The date to filter the storages by their last access date in format YYYY-MM-DD or {number} {unit}.

## `filterAccessedAfter` (type: `string`):

The date to filter the storages by their last access date in format YYYY-MM-DD or {number} {unit}.

## `filterItemCountMin` (type: `integer`):

The minimum number of items in the storages to include in the output.

## `filterItemCountMax` (type: `integer`):

The maximum number of items in the storages to include in the output.

## `filterCleanItemCountMin` (type: `integer`):

The minimum number of clean items in the storages to include in the output.

## `filterCleanItemCountMax` (type: `integer`):

The maximum number of clean items in the storages to include in the output.

## `filterActId` (type: `array`):

The actor ID to filter the storages by.

## `filterActRunId` (type: `array`):

The run ID to filter the storages by.

## `filterReadCountMin` (type: `integer`):

The minimum number of times the storages have been read to include in the output.

## `filterReadCountMax` (type: `integer`):

The maximum number of times the storages have been read to include in the output.

## `filterWriteCountMin` (type: `integer`):

The minimum number of times the storages have been written to include in the output.

## `filterWriteCountMax` (type: `integer`):

The maximum number of times the storages have been written to include in the output.

## `filterDeleteCountMin` (type: `integer`):

The minimum number of times the storages have been deleted to include in the output.

## `filterDeleteCountMax` (type: `integer`):

The maximum number of times the storages have been deleted to include in the output.

## `filterListCountMin` (type: `integer`):

The minimum number of times the storages have been listed to include in the output.

## `filterListCountMax` (type: `integer`):

The maximum number of times the storages have been listed to include in the output.

## `filterS3StorageBytesMin` (type: `integer`):

The minimum number of bytes in the storages to include in the output.

## `filterS3StorageBytesMax` (type: `integer`):

The maximum number of bytes in the storages to include in the output.

## `filterGeneralAccess` (type: `array`):

The general access level to filter the storages by.

## `apifyToken` (type: `string`):

The Apify API token to use for authentication. If not provided, the token from the environment variable APIFY\_TOKEN will be used.

## `apifyTokenForPreviousRun` (type: `string`):

The Apify API token to use for authentication when querying the previous run. If not provided, the current user's token will be used.

## Actor input object example

```json
{
  "datasetIds": [],
  "keyValueStoreIds": [],
  "storageKinds": [
    "key-value-store",
    "dataset"
  ],
  "includeUnnamed": false,
  "outputFields": [
    "name",
    "userId",
    "username",
    "createdAt",
    "modifiedAt",
    "accessedAt",
    "itemCount",
    "cleanItemCount",
    "actId",
    "actRunId",
    "readCount",
    "writeCount",
    "deleteCount",
    "listCount",
    "s3StorageBytes",
    "formattedSize",
    "generalAccess"
  ],
  "sortOutputOrder": "asc",
  "filterUserId": [],
  "filterActId": [],
  "filterActRunId": [],
  "filterGeneralAccess": []
}
```

# 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("marco.gullo/storage-tools").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("marco.gullo/storage-tools").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 marco.gullo/storage-tools --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Storage Tools",
        "description": "Query storages on the Apify platform.",
        "version": "0.0",
        "x-build-id": "xZj1n6J3wIUdx89ZC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/marco.gullo~storage-tools/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-marco.gullo-storage-tools",
                "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/marco.gullo~storage-tools/runs": {
            "post": {
                "operationId": "runs-sync-marco.gullo-storage-tools",
                "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/marco.gullo~storage-tools/run-sync": {
            "post": {
                "operationId": "run-sync-marco.gullo-storage-tools",
                "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": {
                    "datasetIds": {
                        "title": "Dataset IDs",
                        "minItems": 0,
                        "type": "array",
                        "description": "The IDs or the username~store-name of the datasets to query.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyValueStoreIds": {
                        "title": "Key-Value Store IDs",
                        "minItems": 0,
                        "type": "array",
                        "description": "The IDs or the username~store-name of the key-value stores to query.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "previousRunId": {
                        "title": "Previous run ID",
                        "type": "string",
                        "description": "Use the output of a previous run."
                    },
                    "storageKinds": {
                        "title": "Storage kinds",
                        "minItems": 1,
                        "type": "array",
                        "description": "The type of storage to query on the account.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "key-value-store",
                                "dataset"
                            ],
                            "enumTitles": [
                                "Key-Value Store",
                                "Dataset"
                            ]
                        },
                        "default": [
                            "key-value-store",
                            "dataset"
                        ]
                    },
                    "includeUnnamed": {
                        "title": "Include unnamed storages",
                        "type": "boolean",
                        "description": "Whether to include storages without a name.",
                        "default": false
                    },
                    "outputFields": {
                        "title": "Output fields",
                        "minItems": 0,
                        "type": "array",
                        "description": "The fields to include in the output.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "name",
                                "userId",
                                "username",
                                "createdAt",
                                "modifiedAt",
                                "accessedAt",
                                "itemCount",
                                "cleanItemCount",
                                "actId",
                                "actRunId",
                                "readCount",
                                "writeCount",
                                "deleteCount",
                                "listCount",
                                "s3StorageBytes",
                                "formattedSize",
                                "generalAccess"
                            ],
                            "enumTitles": [
                                "Name",
                                "User ID",
                                "Username",
                                "Created At",
                                "Modified At",
                                "Accessed At",
                                "Item Count",
                                "Clean Item Count",
                                "Actor ID",
                                "Run ID",
                                "Read Count",
                                "Write Count",
                                "Delete Count",
                                "List Count",
                                "S3 Storage Bytes",
                                "Formatted Size",
                                "General Access"
                            ]
                        },
                        "default": [
                            "name",
                            "userId",
                            "username",
                            "createdAt",
                            "modifiedAt",
                            "accessedAt",
                            "itemCount",
                            "cleanItemCount",
                            "actId",
                            "actRunId",
                            "readCount",
                            "writeCount",
                            "deleteCount",
                            "listCount",
                            "s3StorageBytes",
                            "formattedSize",
                            "generalAccess"
                        ]
                    },
                    "sortOutputBy": {
                        "title": "Sort output by",
                        "enum": [
                            "id",
                            "name",
                            "userId",
                            "username",
                            "createdAt",
                            "modifiedAt",
                            "accessedAt",
                            "itemCount",
                            "cleanItemCount",
                            "actId",
                            "actRunId",
                            "readCount",
                            "writeCount",
                            "deleteCount",
                            "listCount",
                            "s3StorageBytes",
                            "generalAccess"
                        ],
                        "type": "string",
                        "description": "The key to sort the output by."
                    },
                    "sortOutputOrder": {
                        "title": "Sort output order",
                        "enum": [
                            "asc",
                            "desc"
                        ],
                        "type": "string",
                        "description": "The order to sort the output by.",
                        "default": "asc"
                    },
                    "filterNameByRegex": {
                        "title": "Filter storages by name regex",
                        "type": "string",
                        "description": "A regular expression to filter the storages by their names."
                    },
                    "filterUserId": {
                        "title": "Filter storages by user ID",
                        "type": "array",
                        "description": "The user ID to filter the storages by.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "filterUsernameByRegex": {
                        "title": "Filter storages by username regex",
                        "type": "string",
                        "description": "A regular expression to filter the storages by their usernames."
                    },
                    "filterCreatedBefore": {
                        "title": "Filter storages created before",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "The date to filter the storages by their creation date in format YYYY-MM-DD or {number} {unit}."
                    },
                    "filterCreatedAfter": {
                        "title": "Filter storages created after",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "The date to filter the storages by their creation date in format YYYY-MM-DD or {number} {unit}."
                    },
                    "filterModifiedBefore": {
                        "title": "Filter storages modified before",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "The date to filter the storages by their last modification date in format YYYY-MM-DD or {number} {unit}."
                    },
                    "filterModifiedAfter": {
                        "title": "Filter storages modified after",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "The date to filter the storages by their last modification date in format YYYY-MM-DD or {number} {unit}."
                    },
                    "filterAccessedBefore": {
                        "title": "Filter storages accessed before",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "The date to filter the storages by their last access date in format YYYY-MM-DD or {number} {unit}."
                    },
                    "filterAccessedAfter": {
                        "title": "Filter storages accessed after",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$|^(\\d+)\\s*(day|week|month|year)s?$",
                        "type": "string",
                        "description": "The date to filter the storages by their last access date in format YYYY-MM-DD or {number} {unit}."
                    },
                    "filterItemCountMin": {
                        "title": "Filter storages with item count at least",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The minimum number of items in the storages to include in the output."
                    },
                    "filterItemCountMax": {
                        "title": "Filter storages with item count at most",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The maximum number of items in the storages to include in the output."
                    },
                    "filterCleanItemCountMin": {
                        "title": "Filter storages with clean item count at least",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The minimum number of clean items in the storages to include in the output."
                    },
                    "filterCleanItemCountMax": {
                        "title": "Filter storages with clean item count at most",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The maximum number of clean items in the storages to include in the output."
                    },
                    "filterActId": {
                        "title": "Filter storages by actor ID",
                        "type": "array",
                        "description": "The actor ID to filter the storages by.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "filterActRunId": {
                        "title": "Filter storages by run ID",
                        "type": "array",
                        "description": "The run ID to filter the storages by.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "filterReadCountMin": {
                        "title": "Filter storages with read count at least",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The minimum number of times the storages have been read to include in the output."
                    },
                    "filterReadCountMax": {
                        "title": "Filter storages with read count at most",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The maximum number of times the storages have been read to include in the output."
                    },
                    "filterWriteCountMin": {
                        "title": "Filter storages with write count at least",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The minimum number of times the storages have been written to include in the output."
                    },
                    "filterWriteCountMax": {
                        "title": "Filter storages with write count at most",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The maximum number of times the storages have been written to include in the output."
                    },
                    "filterDeleteCountMin": {
                        "title": "Filter storages with delete count at least",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The minimum number of times the storages have been deleted to include in the output."
                    },
                    "filterDeleteCountMax": {
                        "title": "Filter storages with delete count at most",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The maximum number of times the storages have been deleted to include in the output."
                    },
                    "filterListCountMin": {
                        "title": "Filter storages with list count at least",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The minimum number of times the storages have been listed to include in the output."
                    },
                    "filterListCountMax": {
                        "title": "Filter storages with list count at most",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The maximum number of times the storages have been listed to include in the output."
                    },
                    "filterS3StorageBytesMin": {
                        "title": "Filter storages with S3 storage bytes at least",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The minimum number of bytes in the storages to include in the output."
                    },
                    "filterS3StorageBytesMax": {
                        "title": "Filter storages with S3 storage bytes at most",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The maximum number of bytes in the storages to include in the output."
                    },
                    "filterGeneralAccess": {
                        "title": "Filter storages by general access",
                        "type": "array",
                        "description": "The general access level to filter the storages by.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "FOLLOW_USER_SETTING",
                                "RESTRICTED",
                                "ANYONE_WITH_ID_CAN_READ",
                                "ANYONE_WITH_NAME_CAN_READ"
                            ]
                        },
                        "default": []
                    },
                    "apifyToken": {
                        "title": "Apify Token",
                        "type": "string",
                        "description": "The Apify API token to use for authentication. If not provided, the token from the environment variable APIFY_TOKEN will be used."
                    },
                    "apifyTokenForPreviousRun": {
                        "title": "Apify Token for previous run",
                        "type": "string",
                        "description": "The Apify API token to use for authentication when querying the previous run. If not provided, the current user's token will be used."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
