# EU Machinery Regulation 2023/1230 Technical File Gap Checker (`jadelike_zine/eu-machinery-techfile-gap-checker`) Actor

Check a machinery technical file against EU Machinery Regulation 2023/1230 (applies 20 Jan 2027): extract covered topics with verbatim quotes, then list the missing Annex III EHSR and Annex IV items — flagging the NEW cybersecurity, software-update and AI requirements legacy files lack.

- **URL**: https://apify.com/jadelike\_zine/eu-machinery-techfile-gap-checker.md
- **Developed by:** [Derrick](https://apify.com/jadelike_zine) (community)
- **Categories:** Agents, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$200.00 / 1,000 technical file checkeds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## EU Machinery Regulation 2023/1230 Technical File Gap Checker

**What it does (for agents & pipelines):** give it a machinery **technical file** (or its table of contents / section text) as text or a public URL/PDF, and it returns a structured **readiness / gap report** against **EU Machinery Regulation (EU) 2023/1230** — the topics your file covers (each with a verbatim quote), then the missing **Annex III essential health & safety requirements (EHSR)** and **Annex IV technical-file contents**, with special emphasis on the **NEW 2023 requirements** (cybersecurity, software updates, AI/autonomous behaviour, connectivity, human-robot collaboration) that files ported from the old Directive 2006/42/EC almost always lack. Machine-readable, pay-per-document, no seat license.

Returns, as structured JSON:

- ✅ **Covered topics** the file actually addresses, each with a **verbatim `source_quote`** — nothing invented
- ✅ **Detected features** (connected / software / AI / collaborative) that determine which requirements apply
- ✅ **Annex III EHSR gaps** and **Annex IV technical-file gaps** — the missing items, each with its Annex reference, a `critical`/`high`/`medium` severity, and a plain-English *why*
- ✅ **`new_requirement_gaps`** — the differentiator: the **new-under-2023/1230** requirements (cybersecurity Annex III 1.1.9, software updates, AI/self-evolving behaviour, connectivity, human-robot collaboration) your file doesn't address — the exact blind spot when a 2006/42/EC file is reused
- ✅ An overall **`readiness`** signal (`likely-incomplete` / `partial` / `substantially-documented`)

Built for **machinery manufacturers, EU authorised representatives, and CE-compliance consultants** preparing for the hard **20 January 2027** application date (no grace period). Where an hour of consultant time or a Notified Body is the only alternative, this triages a technical file in seconds so effort goes to the real gaps.

### Why the gaps are trustworthy

The model only extracts **which topics the file covers, with verbatim quotes**. It never decides what's missing and never judges conformity. **Deterministic code** compares that coverage to a curated checklist (`rules/ce-techfile-rules.json`) built from **Annex III (EHSR)** and **Annex IV (technical documentation)** of Regulation (EU) 2023/1230, and it only demands the connectivity/cybersecurity/AI/collaboration requirements when the file's own text shows those features. Every gap carries its Annex reference.

### Input

```json
{
  "documents": [
    { "id": "machine-1", "product_type": "packaging machine",
      "text": "Technical File ... Risk assessment per EN ISO 12100 ... connects to the plant network ..." },
    { "id": "machine-2", "url": "https://example.com/public-technical-file.pdf" }
  ]
}
````

1–20 documents per run. Provide `text` (paste the technical file or its contents list — fastest and most reliable) **or** a `url` to a public page/PDF (fetched best-effort). Optional `product_type` and `id` are echoed back.

### Output (per document)

```json
{
  "detected_features": ["connected", "software"],
  "new_requirement_gaps": [
    { "id": "protection-against-corruption", "annex_ref": "III 1.1.9", "severity": "high", "new_2023": true,
      "label": "Cybersecurity — protection against corruption ...",
      "why": "NEW under 2023/1230 (Annex III 1.1.9): connecting a device or allowing remote communication must not create a hazard ..." }
  ],
  "ehsr_gaps": [ /* non-new Annex III gaps */ ],
  "techfile_gaps": [ /* Annex IV contents missing */ ],
  "readiness": "partial",
  "counts": { "covered_items": 8, "ehsr_gaps": 1, "techfile_gaps": 2, "new_requirement_gaps": 2 },
  "disclaimer": "..."
}
```

### vs. TÜV / Intertek / Nemko and CE consultants

Notified Bodies and CE consultants ([TÜV](https://www.tuv.com/), [Intertek](https://www.intertek.com/), [Nemko](https://www.nemko.com/)) do the authoritative assessment — and for Annex I high-risk machinery you still need them. But there is no self-serve, per-document tool to **triage a technical file before** you engage one. This Actor fills that gap: pay-per-document, API-first, agent-friendly, and focused on the highest-value question for the 2027 deadline — *does your existing file even address the new cybersecurity / software / AI requirements?* Use a Notified Body for conformity assessment; use this to know where your file stands and what to fix first.

### Limits (read this)

- **NOT a conformity assessment, NOT a Notified Body opinion, and NOT legal advice.** It is a readiness/gap triage. It cannot certify compliance.
- Gap detection is **heuristic pattern matching** (v0.1) over the text you provide — a topic mentioned counts as "addressed," so a thin mention can mask a substantive gap, and applicability of each EHSR still needs your engineering judgement. Confirm requirements and the conformity-assessment route against the Regulation text; for Annex I high-risk machinery, engage a Notified Body.
- Extraction is **text-only** and depends on document quality. Garbage in → low `quote_hit_ratio` → not billed.

### Fair charging

Pay per successfully processed document (`techfile-checked`). Failed fetches, non-technical-file text, low-verification extractions, and documents skipped after your run's charge limit is reached are **not charged**. Every `source_quote` is re-verified verbatim against the document before the run is billable.

### Development

```bash
pnpm install
pnpm typecheck   # tsc --noEmit
pnpm test        # vitest: rules table, validate layer, gap analysis
pnpm smoke       # offline end-to-end (no network, no LLM)
pnpm golden      # real-LLM acceptance vs hand-labeled technical-file samples (needs DEEPSEEK_API_KEY)
```

Architecture (single-direction deps): `main → fetch/extract/validate/match → rules → domain`. Same three-layer engine as the GovCon and CPSC actors; the Annex III / Annex IV checklist is the moat.

### Current-source verification

Checklist grounded in primary sources retrieved 2026-07-18: full text (Annex III EHSR, Annex IV technical documentation) — [Regulation (EU) 2023/1230, EUR-Lex](https://eur-lex.europa.eu/eli/reg/2023/1230/oj/eng); 20 January 2027 application date and the new AI/cybersecurity/IoT/software-update requirements — [TÜV Rheinland](https://www.tuv.com/world/en/new-machinery-regulation-eu-2023-1230.html); cybersecurity in Annex III 1.1.9 / 1.2.1 — [Nemko](https://www.nemko.com/blog/eu-machinery-regulation-2023/1230).

# Actor input Schema

## `documents` (type: `array`):

1-20 machinery technical-file documents. Each item: `text` to paste the technical file / table of contents / section text OR `url` to a public page/PDF (fetched best-effort). Optional `product_type` (e.g. 'industrial robot', 'packaging machine') and `id` are echoed back. This tool screens readiness against EU Machinery Regulation 2023/1230 — it is NOT a conformity assessment or Notified Body opinion.

## Actor input object example

```json
{
  "documents": [
    {
      "id": "legacy-file",
      "product_type": "networked packaging machine",
      "text": "Technical File — Automatic Packaging Machine Model PK-200. Contents: 1. General description of the machinery and intended use. 2. Risk assessment carried out per EN ISO 12100, hazards identified and reduced. 3. Guards and interlocks for moving parts. 4. Emergency stop function per EN ISO 13850. 5. Control system safety, performance level PL d per EN ISO 13849. 6. Overall drawing and circuit diagrams. 7. Harmonised standards applied. 8. EU Declaration of Conformity. 9. Instructions for use. The machine connects to the plant network for remote diagnostics and receives firmware over the network."
    },
    {
      "id": "modern-file",
      "product_type": "collaborative robot",
      "text": "Technical documentation for collaborative robot CR-10. Includes: general description and intended use; documented iterative risk assessment; guarding strategy; emergency stop; functional safety of the control system (SIL 2); cybersecurity — protection against corruption of safety software and secure remote access; secure firmware update mechanism; human-robot collaborative operation safety per ISO/TS 15066; harmonised standards applied; test reports; EU Declaration of Conformity; conformity assessment via Notified Body; instructions for use."
    }
  ]
}
```

# 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 = {
    "documents": [
        {
            "id": "legacy-file",
            "product_type": "networked packaging machine",
            "text": "Technical File — Automatic Packaging Machine Model PK-200. Contents: 1. General description of the machinery and intended use. 2. Risk assessment carried out per EN ISO 12100, hazards identified and reduced. 3. Guards and interlocks for moving parts. 4. Emergency stop function per EN ISO 13850. 5. Control system safety, performance level PL d per EN ISO 13849. 6. Overall drawing and circuit diagrams. 7. Harmonised standards applied. 8. EU Declaration of Conformity. 9. Instructions for use. The machine connects to the plant network for remote diagnostics and receives firmware over the network."
        },
        {
            "id": "modern-file",
            "product_type": "collaborative robot",
            "text": "Technical documentation for collaborative robot CR-10. Includes: general description and intended use; documented iterative risk assessment; guarding strategy; emergency stop; functional safety of the control system (SIL 2); cybersecurity — protection against corruption of safety software and secure remote access; secure firmware update mechanism; human-robot collaborative operation safety per ISO/TS 15066; harmonised standards applied; test reports; EU Declaration of Conformity; conformity assessment via Notified Body; instructions for use."
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jadelike_zine/eu-machinery-techfile-gap-checker").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 = { "documents": [
        {
            "id": "legacy-file",
            "product_type": "networked packaging machine",
            "text": "Technical File — Automatic Packaging Machine Model PK-200. Contents: 1. General description of the machinery and intended use. 2. Risk assessment carried out per EN ISO 12100, hazards identified and reduced. 3. Guards and interlocks for moving parts. 4. Emergency stop function per EN ISO 13850. 5. Control system safety, performance level PL d per EN ISO 13849. 6. Overall drawing and circuit diagrams. 7. Harmonised standards applied. 8. EU Declaration of Conformity. 9. Instructions for use. The machine connects to the plant network for remote diagnostics and receives firmware over the network.",
        },
        {
            "id": "modern-file",
            "product_type": "collaborative robot",
            "text": "Technical documentation for collaborative robot CR-10. Includes: general description and intended use; documented iterative risk assessment; guarding strategy; emergency stop; functional safety of the control system (SIL 2); cybersecurity — protection against corruption of safety software and secure remote access; secure firmware update mechanism; human-robot collaborative operation safety per ISO/TS 15066; harmonised standards applied; test reports; EU Declaration of Conformity; conformity assessment via Notified Body; instructions for use.",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jadelike_zine/eu-machinery-techfile-gap-checker").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 '{
  "documents": [
    {
      "id": "legacy-file",
      "product_type": "networked packaging machine",
      "text": "Technical File — Automatic Packaging Machine Model PK-200. Contents: 1. General description of the machinery and intended use. 2. Risk assessment carried out per EN ISO 12100, hazards identified and reduced. 3. Guards and interlocks for moving parts. 4. Emergency stop function per EN ISO 13850. 5. Control system safety, performance level PL d per EN ISO 13849. 6. Overall drawing and circuit diagrams. 7. Harmonised standards applied. 8. EU Declaration of Conformity. 9. Instructions for use. The machine connects to the plant network for remote diagnostics and receives firmware over the network."
    },
    {
      "id": "modern-file",
      "product_type": "collaborative robot",
      "text": "Technical documentation for collaborative robot CR-10. Includes: general description and intended use; documented iterative risk assessment; guarding strategy; emergency stop; functional safety of the control system (SIL 2); cybersecurity — protection against corruption of safety software and secure remote access; secure firmware update mechanism; human-robot collaborative operation safety per ISO/TS 15066; harmonised standards applied; test reports; EU Declaration of Conformity; conformity assessment via Notified Body; instructions for use."
    }
  ]
}' |
apify call jadelike_zine/eu-machinery-techfile-gap-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=jadelike_zine/eu-machinery-techfile-gap-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EU Machinery Regulation 2023/1230 Technical File Gap Checker",
        "description": "Check a machinery technical file against EU Machinery Regulation 2023/1230 (applies 20 Jan 2027): extract covered topics with verbatim quotes, then list the missing Annex III EHSR and Annex IV items — flagging the NEW cybersecurity, software-update and AI requirements legacy files lack.",
        "version": "0.1",
        "x-build-id": "eLl5r6NByoIrHJwzq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jadelike_zine~eu-machinery-techfile-gap-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jadelike_zine-eu-machinery-techfile-gap-checker",
                "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/jadelike_zine~eu-machinery-techfile-gap-checker/runs": {
            "post": {
                "operationId": "runs-sync-jadelike_zine-eu-machinery-techfile-gap-checker",
                "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/jadelike_zine~eu-machinery-techfile-gap-checker/run-sync": {
            "post": {
                "operationId": "run-sync-jadelike_zine-eu-machinery-techfile-gap-checker",
                "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": [
                    "documents"
                ],
                "properties": {
                    "documents": {
                        "title": "Technical file documents",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "1-20 machinery technical-file documents. Each item: `text` to paste the technical file / table of contents / section text OR `url` to a public page/PDF (fetched best-effort). Optional `product_type` (e.g. 'industrial robot', 'packaging machine') and `id` are echoed back. This tool screens readiness against EU Machinery Regulation 2023/1230 — it is NOT a conformity assessment or Notified Body opinion."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
