# GitHub Actions Security & Maintenance Monitor (`automation-lab/github-actions-security-maintenance-monitor`) Actor

🔎 Vet third-party GitHub Actions with public repository, release, policy, advisory, and maintenance evidence for recurring CI dependency reviews.

- **URL**: https://apify.com/automation-lab/github-actions-security-maintenance-monitor.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## GitHub Actions Security & Maintenance Monitor

Monitor the public maintenance and security signals behind the GitHub Actions your CI workflows depend on.

### What does it do?

Submit Marketplace URLs or references such as `actions/checkout@v4`.
The actor resolves public GitHub evidence into one action-focused report.
It joins repository, release, activity, license, policy, and advisory signals.
Every record includes source-level fetch status and source URLs.
The output is an evidence aid, not a security guarantee or vulnerability scan.

### Who is it for?

- Platform engineers reviewing reusable workflow dependencies.
- DevOps teams maintaining an approved-actions inventory.
- Security teams refreshing third-party CI dependency reviews.
- Engineering leaders who need explainable public maintenance evidence.
- Procurement or compliance teams collecting a lightweight review trail.

### Why use it?

GitHub Actions are software supply-chain dependencies.
A Marketplace page alone does not show repository activity or release freshness.
A repository alone may not show how an action is presented in Marketplace.
This monitor keeps the workflow focused on submitted dependencies, not catalogue scraping.
Use scheduled runs to re-check the same approved action list over time.

### Public evidence sources

The actor uses public GitHub Marketplace HTML when a Marketplace URL is supplied.
It calls public repository, latest-release, and community-profile endpoints.
When enabled, it requests GitHub's public repository advisory endpoint.
GitHub can rate-limit or withhold individual sources without authentication.
`sourceFetchStatus` makes those conditions explicit in each output record.

### Data fields

| Field | Meaning |
|---|---|
| `canonicalRepository` | Resolved `owner/repository` backing the action |
| `requestedRef` | Version or ref supplied after `@` |
| `maintenanceRisk` | Transparent low, medium, high, or unknown evidence classification |
| `riskReasons` | Public-signal reasons used for the classification |
| `latestReleaseTag` | Latest public release tag when available |
| `securityPolicyPresent` | GitHub community-profile security-policy signal |
| `sourceFetchStatus` | Per-source success, absence, limit, skip, or error status |

### How risk classification works

High risk is assigned for strong public maintenance warning signals.
Examples include an archived repository, disabled repository, or high/critical advisory.
Medium risk identifies softer review signals such as missing policy or license metadata.
Low means the checked public signals did not trigger a listed reason.
Unknown means the action could not be resolved or key public metadata was unavailable.
Review the underlying fields and your organization’s policy before making a decision.

### Input: action references

Use an action reference such as `actions/checkout@v4`.
Use a Marketplace URL such as `https://github.com/marketplace/actions/cache`.
Each submitted value creates one dataset report.
References are preserved in `inputAction` so reports can be joined to your inventory.
Keep action references explicit and versioned in your source workflow where possible.

### Input: Marketplace metadata

Enable Marketplace metadata to resolve the supplied Marketplace page.
The output can include its title, canonical repository, and verified-creator signal.
This option is useful for Marketplace-originated dependency lists.
Disable it when you already supply direct repository references and want fewer requests.
Marketplace markup can change, so inspect `sourceFetchStatus` in automated workflows.

### Input: public advisories

Enable advisory lookup to request GitHub's public repository advisory endpoint.
The actor reports an advisory count and highest severity where available.
It does not claim complete advisory coverage or scan source code.
Private alerts, authenticated endpoint behavior, and GitHub rate limits can affect availability.
Treat absent data as unavailable evidence, not proof that no vulnerabilities exist.

### Input: run limits

`maxItems` caps the number of submitted action values emitted in one run.
Start with a small value while testing a new workflow.
For an inventory review, submit a list of specific action references.
For scheduled monitoring, reuse a controlled list stored in your task input.
The actor does not discover or enumerate Marketplace actions by itself.

### Output: repository health

Repository fields include description, default branch, archive and disabled flags.
Activity fields include stars, forks, open issues, last push, and last update timestamps.
License output uses the public SPDX identifier or GitHub license key when reported.
Latest release fields provide tag, date, and a release URL where available.
These are public indicators; they are not a maintainer endorsement or code-quality score.

### Output: security context

`securityPolicyPresent` is derived from GitHub's public community profile.
`publicAdvisoryCount` and `highestAdvisorySeverity` are available when enabled and returned.
`disclaimer` is included in every row to preserve the assessment boundary in exports.
Use the output as evidence to prioritize deeper review, not to approve an action automatically.
Consult your security team for policy, threat modeling, and vulnerability remediation decisions.

### Output: source transparency

Each report includes `sourceUrls` for the public pages and APIs consulted.
Each source has a status of `ok`, `not_found`, `rate_limited`, `error`, or `skipped`.
A 404 can mean that a particular optional source does not exist.
A rate limit indicates that GitHub restricted unauthenticated access for that response.
This allows downstream automation to distinguish missing data from a failed run.

### How much does it cost to monitor GitHub Actions?

The actor uses pay-per-event pricing: a small start event plus one report event per output item.
Current starting price is $0.005 per run plus $0.000028689 per action report at the Bronze tier.
Volume tiers can reduce the per-report price.
Pricing is shown in the Apify Console before a run and may be updated with notice.
Use `maxItems` to control how many reports a test or scheduled run creates.

### Example input

```json
{
  "actions": ["actions/checkout@v4", "https://github.com/marketplace/actions/cache"],
  "includeMarketplaceMetadata": true,
  "includeAdvisories": true,
  "maxItems": 10
}
````

The first value resolves directly from an action reference.
The second value also collects available Marketplace context.

### Example workflow

Create a task called “Approved CI Action Monitor”.
Add the action references used by your organization’s workflows.
Schedule it weekly or after a dependency-policy change.
Export the dataset to your review system or spreadsheet.
Escalate high-risk reasons into your organization’s existing security review process.

### Tips for reliable monitoring

Use explicit `owner/repository@ref` values instead of ambiguous display names.
Keep the same inventory list across scheduled runs for useful comparisons.
Use low limits for initial validation and inspect source statuses.
Retry later after a GitHub rate limit rather than treating it as negative evidence.
Use direct repository references when Marketplace HTML is not needed.

### Integrations

Send the dataset to a spreadsheet for an approved-actions register.
Use an Apify webhook to open a ticket when a report contains high risk.
Compare exports over time to find archived repositories or stale releases.
Join `canonicalRepository` with your workflow dependency inventory.
Use source URLs in a reviewer-facing audit record.

### API usage: Node.js

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/github-actions-security-maintenance-monitor').call({
  actions: ['actions/checkout@v4'], maxItems: 1,
});
console.log(run.defaultDatasetId);
```

### API usage: Python

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/github-actions-security-maintenance-monitor").call(
    run_input={"actions": ["actions/checkout@v4"], "maxItems": 1})
print(run["defaultDatasetId"])
```

### API usage: cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~github-actions-security-maintenance-monitor/runs?token=YOUR_APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"actions":["actions/checkout@v4"],"maxItems":1}'
```

### MCP

Use this actor from Apify MCP with the scoped tool URL:
`https://mcp.apify.com?tools=automation-lab/github-actions-security-maintenance-monitor`.

Add the scoped server in Claude Code:

```bash
claude mcp add --transport http apify-actions-monitor \
  'https://mcp.apify.com?tools=automation-lab/github-actions-security-maintenance-monitor'
```

For Claude Desktop, add this MCP server configuration and restart the app:

```json
{"mcpServers":{"apify-actions-monitor":{"url":"https://mcp.apify.com?tools=automation-lab/github-actions-security-maintenance-monitor"}}}
```

Authorize your Apify account when prompted.
Example prompt: “Monitor actions/checkout@v4 and return its latest release and risk reasons.”
Example prompt: “Check these Marketplace action URLs and list unavailable public evidence sources.”
The actor remains useful for targeted dependency review rather than generic GitHub search.

### Legality and responsible use

This actor accesses public GitHub pages and documented public GitHub endpoints.
You are responsible for ensuring your use complies with GitHub terms and applicable law.
Do not use the result to make claims about a maintainer or project without review.
Respect GitHub rate limits and avoid unnecessary high-frequency runs.
Do not treat public metadata as a substitute for a security assessment.

### Limitations

Unauthenticated GitHub API limits can make an optional source unavailable.
Marketplace HTML can change and a page may not expose a linked repository.
Public advisory availability varies by repository and endpoint behavior.
The actor does not inspect workflow YAML, source code, private alerts, or dependencies.
A low classification reflects only the public signals checked by this version.

### Troubleshooting

**Why is maintenance risk unknown?** The Marketplace page may not resolve to a repository, or repository metadata was unavailable.

**Why is advisory output empty?** GitHub may return no public records, restrict the endpoint, or advisory lookup may be disabled.

**Why did a source show rate\_limited?** Wait for GitHub's unauthenticated quota to recover and rerun the affected list.

**Why does a Marketplace URL have a different repository?** Use the emitted `canonicalRepository` and source URL to review the public linkage.

### FAQ

**Does this actor guarantee an action is safe?** No. It is an evidence-based public-signal monitor only.

**Can I monitor the same action repeatedly?** Yes. Reuse a task input and schedule it for periodic checks.

**Does it scrape the full Marketplace?** No. It only evaluates the action values you submit.

**Can I disable optional requests?** Yes. Turn off Marketplace metadata or advisory lookup in input.

### Related scrapers

For broad Marketplace listing discovery, use the [GitHub Marketplace Scraper](https://apify.com/automation-lab/github-marketplace-scraper).
For advisory-centric exports, use the [GitHub Security Advisories Scraper](https://apify.com/automation-lab/github-security-advisories-scraper).
For repository-wide extraction, use the [GitHub Scraper](https://apify.com/automation-lab/github-scraper).
Choose this monitor when the buyer need is ongoing CI action dependency vetting.
The narrow output contract keeps review data focused and explainable.

### Changelog

See [the actor changelog](.actor/CHANGELOG.md) for user-facing release notes.

# Actor input Schema

## `actions` (type: `array`):

GitHub Marketplace action URLs or action references such as actions/checkout@v4. One output record is produced for each entry.

## `includeMarketplaceMetadata` (type: `boolean`):

Resolve Marketplace pages for title, linked repository, and verified-creator signal where publicly shown.

## `includeAdvisories` (type: `boolean`):

Request GitHub's public repository advisory endpoint. Availability is reported per source and can be limited by GitHub.

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

Safety cap for this run. Use a low value while testing.

## Actor input object example

```json
{
  "actions": [
    "actions/checkout@v4",
    "https://github.com/marketplace/actions/cache"
  ],
  "includeMarketplaceMetadata": true,
  "includeAdvisories": true,
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "actions": [
        "actions/checkout@v4",
        "https://github.com/marketplace/actions/cache"
    ],
    "includeMarketplaceMetadata": true,
    "includeAdvisories": true,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/github-actions-security-maintenance-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 = {
    "actions": [
        "actions/checkout@v4",
        "https://github.com/marketplace/actions/cache",
    ],
    "includeMarketplaceMetadata": True,
    "includeAdvisories": True,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/github-actions-security-maintenance-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 '{
  "actions": [
    "actions/checkout@v4",
    "https://github.com/marketplace/actions/cache"
  ],
  "includeMarketplaceMetadata": true,
  "includeAdvisories": true,
  "maxItems": 10
}' |
apify call automation-lab/github-actions-security-maintenance-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/github-actions-security-maintenance-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GitHub Actions Security & Maintenance Monitor",
        "description": "🔎 Vet third-party GitHub Actions with public repository, release, policy, advisory, and maintenance evidence for recurring CI dependency reviews.",
        "version": "0.1",
        "x-build-id": "uPQaYILI3ly53UeCs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~github-actions-security-maintenance-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-github-actions-security-maintenance-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/automation-lab~github-actions-security-maintenance-monitor/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-github-actions-security-maintenance-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/automation-lab~github-actions-security-maintenance-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-github-actions-security-maintenance-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",
                "required": [
                    "actions"
                ],
                "properties": {
                    "actions": {
                        "title": "🔎 Actions to monitor",
                        "type": "array",
                        "description": "GitHub Marketplace action URLs or action references such as actions/checkout@v4. One output record is produced for each entry.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeMarketplaceMetadata": {
                        "title": "Include Marketplace metadata",
                        "type": "boolean",
                        "description": "Resolve Marketplace pages for title, linked repository, and verified-creator signal where publicly shown.",
                        "default": true
                    },
                    "includeAdvisories": {
                        "title": "Check public repository advisories",
                        "type": "boolean",
                        "description": "Request GitHub's public repository advisory endpoint. Availability is reported per source and can be limited by GitHub.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum action records",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Safety cap for this run. Use a low value while testing.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```