# Slovakia RPO Companies Scraper (`parseforge/slovakia-rpo-companies-scraper`) Actor

Query the Slovak Register of Legal Entities by company name or ICO and pull each entity with its ICO, full name history, registered address, legal form, status, business activities, statutory bodies, and establishment dates. Built for due diligence, lead generation, and KYC.

- **URL**: https://apify.com/parseforge/slovakia-rpo-companies-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🇸🇰 Slovakia RPO Companies Scraper

> 🚀 **Pull Slovak legal entities in seconds.** Search the official Register of Legal Entities (RPO) by company name or ICO and get the ICO, full name history, registered address, legal form, business activities, statutory bodies, and establishment and termination dates.

> 🕒 **Last updated:** 2026-06-05 · **📊 25 fields** per record · Covers the full Slovak RPO register · Public, keyless source

The Slovakia RPO Companies Scraper queries the Register of Legal Entities (Register právnických osôb) maintained by the Statistical Office of the Slovak Republic at statistics.sk. Give it a company name (for example `Eset`) or an exact ICO, and it walks every matching entity, fetches the full detail record, and returns one clean row per company.

Coverage spans companies, sole traders, cooperatives, and other registered legal entities across Slovakia, including historical name changes, prior addresses, current statutory bodies and shareholders, the main SK statistical activity, and the source court register reference. Both active and terminated entities are available, controlled by a single toggle.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Sales and lead-gen teams | Build prospect lists of Slovak companies by name keyword |
| Compliance and KYC analysts | Verify ICO, legal form, status, and statutory bodies |
| Researchers and journalists | Track ownership, name history, and company timelines |
| Fintech and data teams | Enrich CRM and risk records with official register data |

### 📋 What the Slovakia RPO Companies Scraper does

- Searches the RPO register by company name (`fullName`) or by exact `ico`.
- Fetches the full entity detail for every search hit.
- Returns identification (ICO, current name, full name history).
- Returns the registered address plus street, building number, postal code, and municipality.
- Returns legal form, current status, establishment and termination dates.
- Returns the main statistical activity, the list of registered business activities, statutory bodies, and shareholders.
- Includes the source court register, registration office, and registration number.
- Lets you cap results and filter to active entities only.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Key | Type | Description |
|---|---|---|---|
| Company Name | `fullName` | string | Search term matched against entity names. Example `Eset`. |
| ICO (Company ID) | `ico` | string | Exact 8 digit Slovak company ID. Example `35895420`. |
| Only Active Entities | `onlyActive` | boolean | When on, terminated entities are excluded. Default true. |
| Max Items | `maxItems` | integer | Cap on number of entities. Free plan is limited to 10. |

Search by name:

```json
{
    "fullName": "Eset",
    "onlyActive": true,
    "maxItems": 10
}
````

Look up a single company by ICO:

```json
{
    "ico": "35895420",
    "onlyActive": false,
    "maxItems": 10
}
```

> ⚠️ **Good to Know:** Provide either a name or an ICO. Name search can return many entities (a search for `Eset` matches over a hundred), so set `maxItems` to control volume. Register text is in Slovak, exactly as published by the source.

### 📊 Output

| Field | Key | Description |
|---|---|---|
| 🆔 ICO | `ico` | Slovak company identification number |
| 📌 Company Name | `fullName` | Current registered name |
| 📊 Status | `status` | Active or Terminated |
| ⚖️ Legal Form | `legalForm` | Legal form name (Slovak) |
| 🏷️ Legal Form Code | `legalFormCode` | Legal form codelist code |
| 🏭 Main Activity | `mainActivity` | Main statistical activity |
| 🏭 Main Activity Code | `mainActivityCode` | Activity codelist code |
| 📍 Address | `addressFull` | Composed registered address |
| 🛣️ Street | `street` | Street name |
| 🏠 Building Number | `buildingNumber` | Building or registration number |
| 📮 Postal Code | `postalCode` | Postal code |
| 🏙️ Municipality | `municipality` | City or town |
| 🌍 Country | `country` | Country of the registered seat |
| 📅 Established | `establishment` | Establishment date |
| 🛑 Terminated | `termination` | Termination date when applicable |
| 🏛️ Register | `registerName` | Source register name |
| ⚖️ Registration Office | `registrationOffice` | Court or office of registration |
| 🔢 Registration Number | `registrationNumber` | Court register file number |
| 📜 Name History | `nameHistory` | Past and present names with valid dates |
| 🧰 Activities | `activities` | List of registered business activities |
| 👤 Statutory Bodies | `statutoryBodies` | Directors with role, dates, address |
| 🤝 Shareholders | `stakeholders` | Shareholders with role and address |
| 🔗 Source | `sourceUrl` | RPO entity detail endpoint |
| 🆔 Entity ID | `entityId` | RPO internal entity id |
| 🕒 Scraped | `scrapedAt` | Collection timestamp |
| ❌ Error | `error` | Null on success, message on failure |

Real sample records from a live run:

```json
{
    "ico": "35895420",
    "fullName": "DOTYKY PRÍRODY s.r.o.",
    "status": "Active",
    "legalForm": "Spoločnosť s ručením obmedzeným",
    "mainActivity": "Veľkoobchod s ostatnými strojmi a zariadeniami",
    "addressFull": "Hradská 1/a, 82107 Bratislava, Slovenská republika",
    "municipality": "Bratislava",
    "establishment": "2004-08-04",
    "registrationNumber": "Sro/32659/B",
    "statutoryBodies": [
        { "name": "Ľubomír Novák", "role": "Konateľ", "validFrom": "2006-03-31", "validTo": null }
    ]
}
```

```json
{
    "ico": "47427965",
    "fullName": "Radko Rešeta, s.r.o.",
    "status": "Active",
    "legalForm": "Spoločnosť s ručením obmedzeným",
    "mainActivity": "Ostatné pomocné obchodné činnosti i. n.",
    "addressFull": "Záhradná 458/17, 972 42 Lehota pod Vtáčnikom, Slovenská republika",
    "municipality": "Lehota pod Vtáčnikom",
    "establishment": "2013-10-04",
    "registrationNumber": "Sro/29032/R"
}
```

```json
{
    "ico": "36052655",
    "fullName": "Atlas Futura Slovakia s.r.o.",
    "status": "Active",
    "legalForm": "Spoločnosť s ručením obmedzeným",
    "mainActivity": "Ostatné pomocné činnosti v doprave",
    "addressFull": "Internátna 67, 97401 Banská Bystrica, Slovenská republika",
    "municipality": "Banská Bystrica",
    "establishment": "2002-02-06",
    "registrationNumber": "Sro/7559/S"
}
```

### ✨ Why choose this Actor

- Reads the official Statistical Office RPO register directly, not a third party copy.
- Returns full name and address history, not just the current values.
- Includes statutory bodies and shareholders for ownership mapping.
- Search by free text or by exact ICO for precise lookups.
- Clean, flat records ready for a CRM, a database, or a spreadsheet.

### 📈 How it compares to alternatives

| Approach | Coverage | Effort | Structure |
|---|---|---|---|
| Manual RPO website lookups | One entity at a time | High | Copy and paste |
| Generic web scrapers | Fragile on dynamic pages | High | Inconsistent |
| Slovakia RPO Companies Scraper | Full register, batched | Low | Clean structured rows |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Slovakia RPO Companies Scraper.
3. Enter a company name or an ICO, and set `onlyActive` and `maxItems`.
4. Click Start and watch entities collect in the run log.
5. Browse the results table or pull them through the Apify API for your app.

### 💼 Business use cases

#### Sales and lead generation

| Goal | How this helps |
|---|---|
| Build a target list | Search a keyword and collect every matching Slovak entity |
| Qualify prospects | Filter to active companies with `onlyActive` |

#### Compliance and KYC

| Goal | How this helps |
|---|---|
| Verify a counterparty | Look up an exact ICO and confirm status and legal form |
| Map control | Read statutory bodies and shareholders per entity |

#### Market and competitor research

| Goal | How this helps |
|---|---|
| Size a segment | Group entities by main activity and municipality |
| Track changes | Use name history and establishment dates over time |

#### Data enrichment

| Goal | How this helps |
|---|---|
| Clean CRM records | Append official ICO, address, and registration number |
| Standardize entities | Use the register name and court reference as keys |

### 🔌 Automating Slovakia RPO Companies Scraper

Connect runs and results to the tools your team already uses:

- **Make** and **Zapier** to trigger runs and route new records.
- **Slack** to post fresh matches to a channel.
- **Airbyte** to sync results into a warehouse.
- **GitHub** to schedule runs from a workflow.
- **Google Drive** to archive each run output.

### 🌟 Beyond business use cases

- **Research:** study company formation trends across Slovak regions.
- **Personal:** check a supplier or employer before you sign.
- **Non-profit:** map the legal entities behind an initiative.
- **Experimentation:** prototype an entity resolution or graph project.

### 🤖 Ask an AI assistant

Drop the output into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Copilot](https://copilot.microsoft.com) and ask it to summarize ownership, cluster by activity, or flag terminated entities.

### ❓ Frequently Asked Questions

**What is the RPO register?**
The Register of Legal Entities maintained by the Statistical Office of the Slovak Republic, a central public reference for Slovak legal entities.

**Do I need an API key?**
No. The source is a public, keyless endpoint.

**Can I look up a single company?**
Yes. Put its 8 digit ICO in the `ico` field.

**Does it include former names?**
Yes. The `nameHistory` field lists past and present names with their valid dates.

**Can I get terminated companies?**
Yes. Turn off `onlyActive` and terminated entities are included with their termination date.

**In what language is the text?**
Slovak, exactly as published by the register.

**How many results can a name search return?**
A common keyword can match well over a hundred entities. Use `maxItems` to cap volume.

**Does it return owners and directors?**
Yes. Statutory bodies and shareholders are included with role, dates, and address when published.

**What does the status field mean?**
Active means no termination date is on record. Terminated means the entity has a termination date.

**Is this affiliated with the Statistical Office?**
No. It is an independent tool that reads only publicly available register data.

### 🔌 Integrate with any app

Every run writes structured records you can pull through the Apify API, push to a webhook, or wire into a scheduled pipeline.

### 🔗 Recommended Actors

- [Estonia Business Register Scraper](https://apify.com/parseforge)
- [NZ Companies Register Scraper](https://apify.com/parseforge)
- [EPA FRS Facility Registry Scraper](https://apify.com/parseforge)
- [SEC XBRL Company Facts Scraper](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with the Statistical Office of the Slovak Republic. Only publicly available data is collected.

# Actor input Schema

## `fullName` (type: `string`):

Search term matched against Slovak legal entity names. Example: Eset. Leave the ICO field empty to search by name.

## `ico` (type: `string`):

Slovak company identification number (ICO), 8 digits. When set, only entities matching this exact ICO are returned. Example: 35895420.

## `onlyActive` (type: `boolean`):

When enabled, only entities that are currently active (not terminated) are returned.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "fullName": "Eset",
  "onlyActive": true,
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "fullName": "Eset",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/slovakia-rpo-companies-scraper").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 = {
    "fullName": "Eset",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/slovakia-rpo-companies-scraper").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 '{
  "fullName": "Eset",
  "maxItems": 10
}' |
apify call parseforge/slovakia-rpo-companies-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/slovakia-rpo-companies-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Slovakia RPO Companies Scraper",
        "description": "Query the Slovak Register of Legal Entities by company name or ICO and pull each entity with its ICO, full name history, registered address, legal form, status, business activities, statutory bodies, and establishment dates. Built for due diligence, lead generation, and KYC.",
        "version": "0.1",
        "x-build-id": "G6fn42Gh1yJ4K7Avx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~slovakia-rpo-companies-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-slovakia-rpo-companies-scraper",
                "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/parseforge~slovakia-rpo-companies-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-slovakia-rpo-companies-scraper",
                "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/parseforge~slovakia-rpo-companies-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-slovakia-rpo-companies-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "fullName": {
                        "title": "Company Name",
                        "type": "string",
                        "description": "Search term matched against Slovak legal entity names. Example: Eset. Leave the ICO field empty to search by name."
                    },
                    "ico": {
                        "title": "ICO (Company ID)",
                        "type": "string",
                        "description": "Slovak company identification number (ICO), 8 digits. When set, only entities matching this exact ICO are returned. Example: 35895420."
                    },
                    "onlyActive": {
                        "title": "Only Active Entities",
                        "type": "boolean",
                        "description": "When enabled, only entities that are currently active (not terminated) are returned.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```