# AWS IAM Service Authorization Drift Monitor (`defenestrator/aws-iam-service-authorization-drift-monitor`) Actor

Monitor official AWS Service Authorization Reference JSON for new IAM actions, resources, condition keys, and permission-surface drift.

- **URL**: https://apify.com/defenestrator/aws-iam-service-authorization-drift-monitor.md
- **Developed by:** [Defenestrator](https://apify.com/defenestrator) (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 $2.00 / 1,000 aws iam authorization drift rows

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

## AWS IAM Service Authorization Drift Monitor

Monitor the official AWS Service Authorization Reference JSON for IAM permission-surface drift: new actions, removed actions, new permission-management actions, resource type changes, condition-key changes, and count mismatches against your baseline.

This Actor is unofficial and is not affiliated with Amazon Web Services. It reads AWS public documentation endpoints only; it does not access your AWS account, credentials, policies, CloudTrail, or private resources.

### What it does

AWS publishes machine-readable Service Authorization Reference files for services such as `s3`, `lambda`, `bedrock`, `iam`, `ec2`, and `organizations`. Those files define IAM actions, resource types, condition keys, and annotations such as `IsWrite` and `IsPermissionManagement`.

This Actor:

- Fetches `https://servicereference.us-east-1.amazonaws.com/v1/service-list.json`.
- Resolves watched services through that official list.
- Fetches each selected service JSON from the AWS-provided URL.
- Computes stable semantic hashes over actions, resources, condition keys, and key AWS annotations.
- Compares against inline baseline rows or a previous Apify dataset.
- Emits one deterministic dataset row per service plus an `OUTPUT.snapshot` suitable for the next scheduled run.

### Repeat-use loop

Run it on a schedule against your critical AWS services. Use the previous run's dataset as `baselineDataset` on the next run. New IAM actions or permission-management actions can then trigger review before your SCP templates, IAM allowlists, policy generators, or least-privilege workflows drift silently.

### Input

Minimum input:

```json
{
  "services": [
    { "service": "s3", "label": "Amazon S3", "critical": true },
    { "service": "lambda", "label": "AWS Lambda", "critical": true },
    { "service": "bedrock", "label": "Amazon Bedrock", "critical": true }
  ],
  "includeUnchangedRows": true
}
````

To compare with a previous run, select the previous dataset with `baselineDataset` in the Apify UI, or pass compact rows in `baselineRows`.

### Output rows

Each dataset row includes:

- `service`, `sourceUrl`, and source modified time from AWS.
- `actionCount`, `writeActionCount`, `permissionManagementActionCount`, `resourceTypeCount`, and `conditionKeyCount`.
- `semanticHash` and `previousSemanticHash`.
- `newActionNames`, `removedActionNames`, and `newPermissionManagementActionNames` when the baseline contains action names.
- `alert`, `priority`, `riskScore`, `alertReasons`, and `recommendedAction`.

### Limitations

- This is a public-reference drift monitor, not an AWS account audit.
- AWS notes that service reference information changes can take up to 24 hours to be reflected.
- Added/removed action names require a previous row that includes `actionNames`; otherwise the Actor still detects semantic/count drift.
- It does not fetch arbitrary user-provided URLs. Service JSON URLs are resolved from AWS `service-list.json` only.

### Pricing

from $2.00 / 1,000 AWS IAM service authorization drift rows

This Actor uses Apify Pay per Event pricing with platform usage included. The row event is charged only for useful rows written to the default dataset.

| Event | Price | Unit |
|---|---:|---|
| Actor start (`apify-actor-start`) | `$0.00005` | Once when the run starts. |
| AWS IAM authorization drift row (`apify-default-dataset-item`) | `$0.002` | Per AWS IAM service authorization drift row. |

A row is one AWS service/action authorization drift row. Apify plan discounts, user-configured max-charge limits, and any future Apify pricing UI changes may affect final charges.

### Related Actors in this portfolio

This Actor is part of the **Cloud platform drift monitors** group. These are narrow, source-specific Apify Actors intended for scheduled checks and repeatable dataset exports — not broad scraped-content feeds.

- [FedRAMP Marketplace Authorization Monitor](https://apify.com/defenestrator/fedramp-marketplace-authorization-monitor) — FedRAMP Marketplace authorization/status monitoring for vendor-risk workflows.
- [AWS IAM Service Authorization Drift Monitor](https://apify.com/defenestrator/aws-iam-service-authorization-drift-monitor) — AWS IAM Service Authorization Reference drift checks for cloud-security reviews.
- [CloudFormation Resource Spec Drift Monitor](https://apify.com/defenestrator/cloudformation-resource-spec-drift-monitor) — CloudFormation resource-spec drift checks for replacement-risk and required-property changes.

Each listing includes its own source notes, limits, pricing, and responsible-use caveats. Use the official source links in each Actor when decisions require verification.

# Actor input Schema

## `services` (type: `array`):

AWS Service Authorization Reference service slugs to monitor. The Actor fetches the official AWS service-list.json and then uses the AWS-provided URL for each selected service; arbitrary user URLs are not fetched.

## `includeAllServices` (type: `boolean`):

If true, monitor every service in AWS service-list.json up to maxServices. Keep false for normal watchlist runs.

## `serviceSearchTerms` (type: `array`):

Optional terms used to select additional services whose slug contains one of the terms, for example bedrock or s3. Terms are matched only against AWS service-list.json slugs.

## `baselineDataset` (type: `string`):

Optional previous run dataset for drift comparison. Use the picker so this limited-permission Actor receives READ access to the selected private dataset.

## `baselineDatasetId` (type: `string`):

Advanced/API fallback for a previous dataset ID. Prefer the picker under limited permissions.

## `baselineRows` (type: `array`):

Optional previous rows or compact baseline snapshots. Include service or rowKey plus semanticHash, actionCount, permissionManagementActionCount, resourceTypeCount, and optionally actionNames for added/removed action details.

## `maxBaselineRows` (type: `integer`):

Maximum rows to read from the selected baseline dataset.

## `maxServices` (type: `integer`):

Maximum number of AWS services to process after watchlist/search/all-service expansion.

## `maxActionNamesInRow` (type: `integer`):

Maximum action names to include directly in each row. Hashes and counts always use the full official action set.

## `includeUnchangedRows` (type: `boolean`):

If false, only alert, changed, or error rows are pushed to the dataset. OUTPUT.snapshot still includes every checked service.

## `alertOnSemanticHashChange` (type: `boolean`):

If true, a changed normalized service hash versus the previous baseline produces an alert.

## `alertOnNewPermissionManagementActions` (type: `boolean`):

If true, new AWS actions marked IsPermissionManagement produce a high-priority alert when action names can be compared against a baseline row.

## `requestTimeoutSecs` (type: `integer`):

Timeout for each official AWS Service Authorization Reference JSON request.

## Actor input object example

```json
{
  "services": [
    {
      "label": "Amazon S3",
      "service": "s3",
      "critical": true
    },
    {
      "label": "AWS Lambda",
      "service": "lambda",
      "critical": true
    },
    {
      "label": "Amazon Bedrock",
      "service": "bedrock",
      "critical": true
    }
  ],
  "includeAllServices": false,
  "serviceSearchTerms": [],
  "baselineRows": [],
  "maxBaselineRows": 2000,
  "maxServices": 25,
  "maxActionNamesInRow": 500,
  "includeUnchangedRows": true,
  "alertOnSemanticHashChange": true,
  "alertOnNewPermissionManagementActions": true,
  "requestTimeoutSecs": 20
}
```

# Actor output Schema

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

Dataset rows: one monitored AWS service per row with action/resource/condition-key drift signals.

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

Run-level summary plus OUTPUT.snapshot for scheduled drift comparison.

# 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 = {
    "services": [
        {
            "label": "Amazon S3",
            "service": "s3",
            "critical": true
        },
        {
            "label": "AWS Lambda",
            "service": "lambda",
            "critical": true
        },
        {
            "label": "Amazon Bedrock",
            "service": "bedrock",
            "critical": true
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("defenestrator/aws-iam-service-authorization-drift-monitor").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 = { "services": [
        {
            "label": "Amazon S3",
            "service": "s3",
            "critical": True,
        },
        {
            "label": "AWS Lambda",
            "service": "lambda",
            "critical": True,
        },
        {
            "label": "Amazon Bedrock",
            "service": "bedrock",
            "critical": True,
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("defenestrator/aws-iam-service-authorization-drift-monitor").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 '{
  "services": [
    {
      "label": "Amazon S3",
      "service": "s3",
      "critical": true
    },
    {
      "label": "AWS Lambda",
      "service": "lambda",
      "critical": true
    },
    {
      "label": "Amazon Bedrock",
      "service": "bedrock",
      "critical": true
    }
  ]
}' |
apify call defenestrator/aws-iam-service-authorization-drift-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=defenestrator/aws-iam-service-authorization-drift-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AWS IAM Service Authorization Drift Monitor",
        "description": "Monitor official AWS Service Authorization Reference JSON for new IAM actions, resources, condition keys, and permission-surface drift.",
        "version": "0.0",
        "x-build-id": "eJJnY4ppOFSVUKkGO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/defenestrator~aws-iam-service-authorization-drift-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-defenestrator-aws-iam-service-authorization-drift-monitor",
                "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/defenestrator~aws-iam-service-authorization-drift-monitor/runs": {
            "post": {
                "operationId": "runs-sync-defenestrator-aws-iam-service-authorization-drift-monitor",
                "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/defenestrator~aws-iam-service-authorization-drift-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-defenestrator-aws-iam-service-authorization-drift-monitor",
                "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": {
                    "services": {
                        "title": "AWS services to monitor",
                        "type": "array",
                        "description": "AWS Service Authorization Reference service slugs to monitor. The Actor fetches the official AWS service-list.json and then uses the AWS-provided URL for each selected service; arbitrary user URLs are not fetched.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "label": {
                                    "type": "string",
                                    "title": "Label",
                                    "description": "Human-readable label for this watched AWS service."
                                },
                                "service": {
                                    "type": "string",
                                    "title": "Service slug",
                                    "description": "AWS Service Authorization Reference slug such as s3, lambda, bedrock, iam, ec2, organizations, or access-analyzer."
                                },
                                "expectedActionCount": {
                                    "type": "integer",
                                    "title": "Expected action count",
                                    "description": "Optional expected number of IAM actions. A mismatch creates an alert; useful when pinning a known baseline without a previous dataset.",
                                    "minimum": 0
                                },
                                "expectedPermissionManagementActionCount": {
                                    "type": "integer",
                                    "title": "Expected permission-management action count",
                                    "description": "Optional expected number of actions marked by AWS as permission-management actions. A mismatch creates an alert.",
                                    "minimum": 0
                                },
                                "expectedResourceTypeCount": {
                                    "type": "integer",
                                    "title": "Expected resource type count",
                                    "description": "Optional expected number of resource types for the service. A mismatch creates an alert.",
                                    "minimum": 0
                                },
                                "critical": {
                                    "type": "boolean",
                                    "title": "Critical service",
                                    "description": "If true, permission-surface drift for this service is raised as higher priority.",
                                    "default": false
                                }
                            }
                        }
                    },
                    "includeAllServices": {
                        "title": "Include all AWS services",
                        "type": "boolean",
                        "description": "If true, monitor every service in AWS service-list.json up to maxServices. Keep false for normal watchlist runs.",
                        "default": false
                    },
                    "serviceSearchTerms": {
                        "title": "Service search terms",
                        "type": "array",
                        "description": "Optional terms used to select additional services whose slug contains one of the terms, for example bedrock or s3. Terms are matched only against AWS service-list.json slugs.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "baselineDataset": {
                        "title": "Previous run dataset",
                        "type": "string",
                        "description": "Optional previous run dataset for drift comparison. Use the picker so this limited-permission Actor receives READ access to the selected private dataset."
                    },
                    "baselineDatasetId": {
                        "title": "Previous dataset ID (advanced)",
                        "type": "string",
                        "description": "Advanced/API fallback for a previous dataset ID. Prefer the picker under limited permissions."
                    },
                    "baselineRows": {
                        "title": "Inline previous rows / baseline snapshots",
                        "type": "array",
                        "description": "Optional previous rows or compact baseline snapshots. Include service or rowKey plus semanticHash, actionCount, permissionManagementActionCount, resourceTypeCount, and optionally actionNames for added/removed action details.",
                        "items": {
                            "type": "object"
                        },
                        "default": []
                    },
                    "maxBaselineRows": {
                        "title": "Max baseline rows to read",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum rows to read from the selected baseline dataset.",
                        "default": 2000
                    },
                    "maxServices": {
                        "title": "Max services",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of AWS services to process after watchlist/search/all-service expansion.",
                        "default": 25
                    },
                    "maxActionNamesInRow": {
                        "title": "Max action names in each dataset row",
                        "minimum": 0,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum action names to include directly in each row. Hashes and counts always use the full official action set.",
                        "default": 500
                    },
                    "includeUnchangedRows": {
                        "title": "Include unchanged rows",
                        "type": "boolean",
                        "description": "If false, only alert, changed, or error rows are pushed to the dataset. OUTPUT.snapshot still includes every checked service.",
                        "default": true
                    },
                    "alertOnSemanticHashChange": {
                        "title": "Alert on semantic hash drift",
                        "type": "boolean",
                        "description": "If true, a changed normalized service hash versus the previous baseline produces an alert.",
                        "default": true
                    },
                    "alertOnNewPermissionManagementActions": {
                        "title": "Alert on new permission-management actions",
                        "type": "boolean",
                        "description": "If true, new AWS actions marked IsPermissionManagement produce a high-priority alert when action names can be compared against a baseline row.",
                        "default": true
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 3,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Timeout for each official AWS Service Authorization Reference JSON request.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```