# Luhn Algorithm Validator (`automation-lab/luhn-validator`) Actor

Validate numbers using the Luhn checksum algorithm. Detects card brands (Visa, Mastercard, Amex, Discover, JCB, Diners Club, Maestro, UnionPay), IMEI, Canadian SINs, and other Luhn-validated IDs. Bulk validation with check digit correction.

- **URL**: https://apify.com/automation-lab/luhn-validator.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

## Luhn Algorithm Validator

Validate numbers using the **Luhn checksum algorithm** (mod 10). Supports credit card numbers, IMEI numbers, Canadian Social Insurance Numbers (SINs), National Provider Identifiers (NPIs), and any other Luhn-validated ID format. Detects card brands (Visa, Mastercard, American Express, Discover, JCB, Diners Club, Maestro, UnionPay) automatically from prefix and length patterns.

### What does Luhn Algorithm Validator do?

Luhn Algorithm Validator takes a list of numbers and validates each one against the Luhn checksum algorithm. For every number, it returns:

- **Validity status** — whether the number passes the Luhn check
- **Check digit analysis** — the actual check digit and the expected check digit (for invalid numbers)
- **Card brand detection** — identifies Visa, Mastercard, Amex, Discover, JCB, Diners Club, Maestro, and UnionPay based on IIN (Issuer Identification Number) prefix ranges
- **Number type classification** — detects payment cards, IMEI numbers, Canadian SINs, NPIs, and other Luhn-validated formats
- **Automatic normalization** — strips spaces, dashes, dots, and parentheses before validation

The Luhn algorithm is used worldwide to validate identification numbers including credit card numbers (ISO/IEC 7812), IMEI numbers for mobile devices, Canadian Social Insurance Numbers, US National Provider Identifiers, and many government-issued IDs.

### Who is Luhn Algorithm Validator for?

- **Fintech developers** validating payment card numbers before processing transactions
- **Data quality engineers** cleaning and validating large datasets of card or ID numbers
- **Fraud detection teams** flagging numbers that fail Luhn checks as potentially fabricated
- **E-commerce platforms** verifying card number formats before calling payment gateways
- **QA engineers** generating and validating test card numbers for payment system testing
- **Compliance teams** auditing PII datasets for valid card and ID number formats
- **Mobile device management** teams validating IMEI numbers in bulk

### Why use Luhn Algorithm Validator?

- **Zero cost per run** — pure computation, no HTTP calls, no proxy, no browser. Runs in milliseconds
- **Bulk processing** — validate thousands of numbers in a single run
- **Card brand detection** — automatically identifies 8 major card networks from IIN prefix patterns
- **Detailed diagnostics** — for invalid numbers, shows the expected check digit so you can correct them
- **Format-tolerant** — handles numbers with spaces, dashes, dots, and parentheses
- **API-ready** — integrate into any pipeline via Apify API, webhooks, or MCP

### What data does Luhn Algorithm Validator return?

| Field | Type | Description |
|-------|------|-------------|
| `number` | string | Original input as provided |
| `numberNormalized` | string | Input with spaces, dashes, dots removed |
| `digitCount` | number | Number of digits after normalization |
| `isValid` | boolean | Whether the number passes the Luhn check |
| `checkDigit` | number | Actual last digit of the number |
| `expectedCheckDigit` | number | Correct check digit (useful for fixing invalid numbers) |
| `numberType` | string | Detected type: Payment Card, IMEI, Canadian SIN, NPI, Other |
| `cardBrand` | string | Card network: Visa, Mastercard, Amex, Discover, JCB, etc. |
| `cardBrandCode` | string | Short code: VISA, MC, AMEX, DISC, JCB, DINERS, MAESTRO, UNIONPAY |
| `iinRange` | string | IIN prefix range that matched (e.g., "4" for Visa, "51-55" for MC) |
| `error` | string | Error message if input is malformed (non-digits, too short) |

### How much does it cost to validate numbers with Luhn algorithm?

Luhn Algorithm Validator uses pay-per-event pricing. You only pay for what you use.

| Event | FREE tier | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
|-------|-----------|--------|--------|------|----------|---------|
| Run started (one-time) | $0.001 | $0.001 | $0.001 | $0.001 | $0.001 | $0.001 |
| Per number validated | $0.000345 | $0.0003 | $0.000234 | $0.00018 | $0.00012 | $0.000084 |

**Example costs (BRONZE tier):**
- 10 numbers: $0.001 + $0.003 = **$0.004**
- 100 numbers: $0.001 + $0.03 = **$0.031**
- 1,000 numbers: $0.001 + $0.30 = **$0.301**
- 10,000 numbers: $0.001 + $3.00 = **$3.001**

**Free plan estimate:** Apify's free tier gives you $5/month in platform credits. That's roughly **14,000 numbers per month** at FREE tier pricing.

### How to validate numbers with Luhn algorithm

1. Go to [Luhn Algorithm Validator](https://apify.com/automation-lab/luhn-validator) on Apify Store
2. Enter your numbers in the input field (one per line or as a JSON array)
3. Click **Start** to run the validator
4. View results in the **Dataset** tab — each number shows validity, check digit, and card brand
5. Export results as JSON, CSV, or Excel, or connect via API

### Input parameters

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `numbers` | array | Yes | List of numbers to validate. Spaces, dashes, and dots are stripped automatically. |

### Output example

```json
{
    "number": "4532015112830366",
    "numberNormalized": "4532015112830366",
    "digitCount": 16,
    "isValid": true,
    "checkDigit": 6,
    "expectedCheckDigit": 6,
    "numberType": "Payment Card",
    "cardBrand": "Visa",
    "cardBrandCode": "VISA",
    "iinRange": "4",
    "error": null
}
````

For invalid numbers, the output includes the expected check digit:

```json
{
    "number": "4532015112830367",
    "numberNormalized": "4532015112830367",
    "digitCount": 16,
    "isValid": false,
    "checkDigit": 7,
    "expectedCheckDigit": 6,
    "numberType": "Payment Card",
    "cardBrand": "Visa",
    "cardBrandCode": "VISA",
    "iinRange": "4",
    "error": null
}
```

### Tips for best results

- **Strip formatting first** — the validator handles spaces, dashes, and dots, but other characters (letters, symbols) will cause an error
- **Use check digit correction** — when `isValid` is false, `expectedCheckDigit` tells you the correct last digit
- **Validate before payment calls** — catching bad card numbers before hitting the payment gateway saves API fees and reduces declines
- **Test card numbers** — use standard test numbers like `4111111111111111` (Visa), `5500000000000004` (Mastercard), `340000000000009` (Amex)
- **Batch for efficiency** — send all numbers in a single run rather than one at a time, the start event is charged only once per run

### Integrations

Luhn Algorithm Validator fits into data processing workflows:

- **Payment form validation** — validate card numbers client-side before submitting to Stripe/PayPal/Braintree
- **ETL pipeline cleaning** — validate a column of card/ID numbers in your data warehouse export, flag invalid rows
- **Fraud detection pipeline** — integrate as a pre-filter: numbers failing Luhn checks are likely fabricated
- **QA test data generation** — validate that your test card number generator produces Luhn-valid numbers
- **Apify webhook chains** — trigger Luhn validation automatically when another actor outputs card-like data

### API usage

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('automation-lab/luhn-validator').call({
    numbers: ['4111111111111111', '5500000000000004', '1234567890'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')
run = client.actor('automation-lab/luhn-validator').call(run_input={
    'numbers': ['4111111111111111', '5500000000000004', '1234567890'],
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~luhn-validator/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{"numbers": ["4111111111111111", "5500000000000004", "1234567890"]}'
```

### MCP integration

Use Luhn Algorithm Validator directly from AI assistants via the Model Context Protocol (MCP).

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/luhn-validator"
```

#### Claude Desktop / Cursor / VS Code

Add to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/luhn-validator"
        }
    }
}
```

**Example prompts:**

- "Validate these credit card numbers: 4111111111111111, 5500000000000004"
- "Check if 374245455400126 is a valid Amex number"
- "Which of these numbers pass the Luhn check?"

### Supported card brands

| Brand | Prefix | Length | Code |
|-------|--------|--------|------|
| Visa | 4 | 13, 16, 19 | VISA |
| Mastercard | 51-55, 2221-2720 | 16 | MC |
| American Express | 34, 37 | 15 | AMEX |
| Discover | 6011, 644-649, 65 | 16-19 | DISC |
| JCB | 3528-3589 | 16-19 | JCB |
| Diners Club | 300-305, 36, 38 | 14, 16, 19 | DINERS |
| Maestro | 5018, 5020, 5038, 6304, 6759-6763 | 12-19 | MAESTRO |
| UnionPay | 62 | 16-19 | UNIONPAY |

### Legality and compliance

The Luhn algorithm is a mathematical checksum formula — it does not access any external services, databases, or APIs. This actor performs **pure computation** on the numbers you provide. No data leaves the Apify platform. No external requests are made. The algorithm itself is public domain (US Patent 2,950,048, expired 1977).

**Important:** This tool validates number FORMAT only (checksum correctness). A Luhn-valid number is not necessarily an active, issued, or authorized card. Never use Luhn validation as a substitute for payment authorization.

### FAQ

**What is the Luhn algorithm?**
The Luhn algorithm (also called the modulus 10 or mod 10 algorithm) is a checksum formula used to validate identification numbers. It was created by IBM scientist Hans Peter Luhn in 1954. It detects single-digit errors and most transpositions of adjacent digits.

**Can this validator check if a credit card is real?**
No. The Luhn algorithm only verifies mathematical correctness of the check digit. A Luhn-valid number may be expired, cancelled, or never issued. Use a payment gateway for authorization checks.

**Why does my number show as invalid?**
Check these common causes: (1) the number has a typo in the last digit — compare `checkDigit` vs `expectedCheckDigit`, (2) the number contains letters or special characters that aren't stripped by normalization, (3) the number is too short (minimum 2 digits).

**Does this work for non-card numbers like IMEI?**
Yes. The Luhn algorithm is the same regardless of number type. The validator also detects number types: IMEI (15 digits starting with 35), Canadian SIN (9 digits), NPI (10 digits), and payment cards (12-19 digits matching known IIN ranges).

**How fast is the validation?**
Very fast — this is pure math with no HTTP requests. A batch of 10,000 numbers completes in under a second. Processing time is O(n) where n is the total number of digits across all input numbers.

### Related tools

- [Base64 Converter](https://apify.com/automation-lab/base64-converter) — encode and decode Base64 strings in bulk
- [IBAN Validator](https://apify.com/automation-lab/iban-validator) — validate International Bank Account Numbers
- [Email Validator](https://apify.com/automation-lab/email-validator) — verify email address format and deliverability

# Actor input Schema

## `numbers` (type: `array`):

List of numbers to validate as strings. Spaces, dashes, and dots are stripped automatically before validation.

## Actor input object example

```json
{
  "numbers": [
    "4111111111111111",
    "5425233430109903",
    "374245455400126",
    "6011514433546201",
    "3530111333300000",
    "79927398713",
    "046 454 286",
    "1234567890"
  ]
}
```

# 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 = {
    "numbers": [
        "4111111111111111",
        "5425233430109903",
        "374245455400126",
        "6011514433546201",
        "3530111333300000",
        "79927398713",
        "046 454 286",
        "1234567890"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/luhn-validator").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 = { "numbers": [
        "4111111111111111",
        "5425233430109903",
        "374245455400126",
        "6011514433546201",
        "3530111333300000",
        "79927398713",
        "046 454 286",
        "1234567890",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/luhn-validator").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 '{
  "numbers": [
    "4111111111111111",
    "5425233430109903",
    "374245455400126",
    "6011514433546201",
    "3530111333300000",
    "79927398713",
    "046 454 286",
    "1234567890"
  ]
}' |
apify call automation-lab/luhn-validator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Luhn Algorithm Validator",
        "description": "Validate numbers using the Luhn checksum algorithm. Detects card brands (Visa, Mastercard, Amex, Discover, JCB, Diners Club, Maestro, UnionPay), IMEI, Canadian SINs, and other Luhn-validated IDs. Bulk validation with check digit correction.",
        "version": "0.1",
        "x-build-id": "iWBm5pdvDPqbenH75"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~luhn-validator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-luhn-validator",
                "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~luhn-validator/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-luhn-validator",
                "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~luhn-validator/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-luhn-validator",
                "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": [
                    "numbers"
                ],
                "properties": {
                    "numbers": {
                        "title": "🔢 Numbers to validate",
                        "type": "array",
                        "description": "List of numbers to validate as strings. Spaces, dashes, and dots are stripped automatically before validation.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```