# Cyprus Company Registry Scraper - DRCOR (`regdata/cyprus-drcor-company-scraper`) Actor

Search the official Cyprus company register (DRCOR) by name or registration number. Returns organisation identity and status, directors and secretary, and registered office. No API key.

- **URL**: https://apify.com/regdata/cyprus-drcor-company-scraper.md
- **Developed by:** [getregdata](https://apify.com/regdata) (community)
- **Categories:** Agents, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 organisation records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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/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

## Cyprus Company Registry Scraper - DRCOR

Look up any Cyprus company in the official register and get back structured JSON: registration
number, status, incorporation date, **directors and secretary**, and the **registered office**.

Source: **DRCOR** - the Department of Registrar of Companies and Intellectual Property, the
official companies register of the Republic of Cyprus.

No account, no API key, no setup.

---

### What data do I get for a Cyprus company?

| | |
|---|---|
| **Identity** | Current name, registration number (`HE6771`), organisation type, private/public sub-type |
| **Former names** | Every earlier name the register still indexes for the company |
| **Status** | File status (Registered, Dissolved, Struck off, Dissolved due to merger...) and the date it took effect |
| **Dates** | Incorporation/registration date, last annual return filed, date the file was last updated |
| **People** | Directors, company secretary and assistant secretary, each with their position |
| **Address** | Registered office as held by the register |
| **Compliance** | Pending filings on the file, and the years the annual company levy has been paid |

```json
{
  "lookupStatus": "found",
  "name": "EUROBANK LIMITED",
  "registrationNumber": "HE6771",
  "registrationNumberRaw": "ΗΕ 6771",
  "organisationType": "Limited Company",
  "subType": "Private",
  "registrationDate": "29/05/1974",
  "organisationStatus": "Reminder letter sent",
  "organisationStatusDate": "09/02/2026",
  "lastAnnualReturnDate": "28/08/2020",
  "registeredOffice": "Λεμεσού & Αθαλάσσας, 200, Στρόβολος, 2025, Λευκωσία, Κύπρος",
  "officers": [
    { "name": "MICHAEL STEFAN REDFERNE", "position": "Director" },
    { "name": "ΠΕΤΡΟΣ ΑΡΣΑΛΙΔΗΣ", "position": "Secretary" }
  ],
  "officerCount": 15,
  "annualFeesPaidYears": ["2023", "2022", "2021"],
  "jurisdiction": "CY",
  "retrievedAt": "2026-07-18T10:04:11.812Z"
}
````

### How do I search?

**By company name** - the usual starting point:

```json
{ "companyName": "HELLENIC BANK", "maxResults": 25 }
```

**By registration number** - exact, one lookup per number:

```json
{ "registrationNumbers": ["HE 6771", "HE217050"] }
```

Any format works: `HE 6771`, `HE6771`, `ΗΕ6771` (Greek letters) or plain `6771`. A bare number
matches that number across **every** organisation type - a limited company `HE`, a business name
`EE` and an overseas company `AE` can all share the digits `6771` - so include the letter prefix
when you want just one.

`searchType` controls name matching: `startsWith` (default), `endsWith`, or `soundsLike`, which
uses the register's own phonetic index and is narrower than a general fuzzy search.

### Why does one company match my search several times?

Because the register indexes a company under **every name it has ever held**. Searching
`EUROBANK` returns `EUROBANK CYPRUS LTD` and `EUROBANK EFG CYPRUS LTD` - both former names of the
same company, which today is called `ERB CYPRUS HOLDINGS LTD`.

This actor merges them into **one record** and keeps the former names in `matchedNames`, so you
get the company once, you are billed once, and the name history - the part that matters for
screening - is not thrown away.

### How much does it cost?

Pay per record. You are charged for each organisation record exported, and for nothing else.

Two things are deliberately **not** billed:

- **Records we could not retrieve.** If the register is unreachable or a file will not open, that
  row is left out of the dataset entirely and listed in `FAILED_INPUTS` in the run's key-value
  store. You do not pay for our breakage.
- **Duplicate listings** of a company under its former names, which are merged before anything is
  retrieved.

A confirmed **"no such company"** IS charged: the register was queried and gave a definitive
answer, which for compliance work is a result in its own right.

### What is a "name application" row?

A reserved company name that has been applied for but has no registered file behind it yet. The
register lists these alongside real companies. They come back as
`"lookupStatus": "name_application"` with `"detailAvailable": false` - so an empty officer list is
never mistaken for a company that genuinely has no directors.

### Does it tell me who owns the company?

**No, and no Cyprus scraper can.** DRCOR does not publish shareholders or beneficial owners on its
public register - only directors and the secretary, which this actor returns in full. Beneficial
ownership sits in a separate, access-controlled register.

Anyone claiming to scrape Cypriot shareholders from the public register is not reading DRCOR.

### Is scraping this data legal?

The DRCOR public search is open to everyone, needs no account, and this actor reads only what that
public search returns - the same pages a person can open in a browser. It queries on demand for
the names you ask about; it does not clone or redistribute the register.

The records are about **companies** - organisation names, registration numbers, statuses,
addresses. Officer names are published by the register itself as a matter of Cyprus company law.
Under GDPR that is a public official source, but you remain the controller of what you do with it
downstream, so use it for legitimate purposes such as KYB, due diligence and compliance.

If you need certified documents or certificates, buy them from DRCOR directly - this actor does
not produce official extracts.

### Do I need an API key or an account?

No. There is no public API for this register, no login and no key to configure. Set a company name
or a registration number and run it.

### How complete are my results?

The register reports its own match count, and this actor reconciles against it. If more matches
exist than were exported - because `maxResults` was reached - the run says so explicitly in its
status message, with the register's own total. A partial run never presents itself as a complete
one.

The same applies inside a record: `pendingServicesCount` is the register's total for that file,
and `pendingServicesTruncated` tells you when more pending filings exist than the rows returned.

### How do I use it from code?

```bash
apify call YOUR_USERNAME/cyprus-drcor-company-scraper \
  --input '{"companyName":"HELLENIC BANK","maxResults":25}'
```

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('YOUR_USERNAME/cyprus-drcor-company-scraper').call({
    registrationNumbers: ['HE 6771'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].officers);
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("YOUR_USERNAME/cyprus-drcor-company-scraper").call(
    run_input={"companyName": "HELLENIC BANK", "maxResults": 25}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["registrationNumber"], item["officerCount"])
```

Works with **n8n**, **Make**, **Zapier** and any HTTP client through the standard Apify API, and
with AI agents over MCP.

### Input reference

| Field | Type | Default | Description |
|---|---|---|---|
| `companyName` | string | - | Company or organisation name to search |
| `registrationNumbers` | array | - | Registration numbers, each looked up separately |
| `searchType` | enum | `startsWith` | `startsWith`, `endsWith` or `soundsLike` |
| `maxResults` | integer | 100 | Maximum organisation records to export |
| `language` | enum | `en` | `en`, `el` or `tr` - language of translated labels and statuses |

Set at least one of `companyName` or `registrationNumbers`. A run with neither fails immediately
and is not charged.

### In what language is the data?

Values the register translates - organisation type, status, officer positions - follow the
`language` setting and default to English.

Company names and addresses come back **exactly as the register holds them**, which for older
Cypriot files is Greek. That is the authoritative form, so it is returned rather than a guess at a
transliteration. Registration numbers are the one exception: the register prints them with Greek
letters (`ΗΕ 6771`), so each record carries both the normalized Latin `registrationNumber`
(`HE6771`) and the original in `registrationNumberRaw`.

### Limitations

- **No shareholders or beneficial owners** - DRCOR does not publish them (see above).
- **No document downloads** - certificates and filed documents are a paid DRCOR service.
- **No officer dates** - the register's public officials list gives name and position, not
  appointment or resignation dates.
- **Pending services are paginated** - the first page is returned, with the register's full count
  and a truncation flag.
- **Officer names are not deduplicated across companies** - there is no person identifier in the
  public register, so two `ΑΝΔΡΕΑΣ ΓΕΩΡΓΙΟΥ` entries cannot be assumed to be the same person.

### Related registry actors

Part of a fleet of official-registry actors across 11+ countries - Poland (KRS, CRBR, KRZ, MSiG,
EKW, KNF, UOKiK, BDO), Germany (Handelsregister), Spain (Registro Mercantil, BORME), Italy,
France, Austria, Belgium, Slovakia (RPVS beneficial owners), Czechia, UAE and California.

For Cyprus specifically, pair this with a sanctions/PEP screen on the officer names it returns.

***

**Data source:** [DRCOR - Department of Registrar of Companies and Intellectual Property](https://efiling.drcor.mcit.gov.cy/DrcorPublic/SearchForm.aspx?sc=0),
Republic of Cyprus. This actor is not affiliated with or endorsed by DRCOR.

# Actor input Schema

## `companyName` (type: `string`):

Company or organisation name to search for. Matching is controlled by the Search type below. Example: 'HELLENIC BANK', 'EUROBANK'. | Όνομα εταιρείας ή οργανισμού.

## `registrationNumbers` (type: `array`):

One or more Cyprus registration numbers, each looked up separately. Accepts any format: 'HE 6771', 'HE6771' or just '6771'. A bare number matches that number across EVERY organisation type (a limited company HE, a business name EE, an overseas company AE...), so include the letter prefix when you want just one type. | Αριθμοί εγγραφής, π.χ. 'ΗΕ 6771'.

## `searchType` (type: `string`):

How the company name is matched. 'Starts with' is the register's default and the most reliable. 'Sounds like' uses the register's own phonetic index, which is narrow - it will not behave like a general fuzzy search.

## `maxResults` (type: `integer`):

Maximum organisation records to export. A company that has traded under several names is listed once per former name in the register; those are merged into a single record here, with the former names kept on it, so you are never charged twice for the same company.

## `language` (type: `string`):

Language for labels and values the register translates - organisation type, status and officer positions. Company names and addresses are returned exactly as the register holds them, which for older Cypriot files is Greek regardless of this setting.

## `proxyConfiguration` (type: `object`):

Leave this off. The register accepts ordinary requests and a normal run does not need a proxy, so you should not pay for one. It is here only for users running many searches in parallel from shared addresses.

## Actor input object example

```json
{
  "companyName": "HELLENIC BANK",
  "registrationNumbers": [
    "HE 6771"
  ],
  "searchType": "startsWith",
  "maxResults": 10,
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `organisations` (type: `string`):

Organisation records with directors, secretary and registered office in the default dataset.

# 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 = {
    "companyName": "HELLENIC BANK",
    "registrationNumbers": [
        "HE 6771"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("regdata/cyprus-drcor-company-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 = {
    "companyName": "HELLENIC BANK",
    "registrationNumbers": ["HE 6771"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("regdata/cyprus-drcor-company-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 '{
  "companyName": "HELLENIC BANK",
  "registrationNumbers": [
    "HE 6771"
  ],
  "maxResults": 10
}' |
apify call regdata/cyprus-drcor-company-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=regdata/cyprus-drcor-company-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cyprus Company Registry Scraper - DRCOR",
        "description": "Search the official Cyprus company register (DRCOR) by name or registration number. Returns organisation identity and status, directors and secretary, and registered office. No API key.",
        "version": "1.0",
        "x-build-id": "SaeM3qbrLUS61fELG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/regdata~cyprus-drcor-company-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-regdata-cyprus-drcor-company-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/regdata~cyprus-drcor-company-scraper/runs": {
            "post": {
                "operationId": "runs-sync-regdata-cyprus-drcor-company-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/regdata~cyprus-drcor-company-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-regdata-cyprus-drcor-company-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": {
                    "companyName": {
                        "title": "Company name",
                        "type": "string",
                        "description": "Company or organisation name to search for. Matching is controlled by the Search type below. Example: 'HELLENIC BANK', 'EUROBANK'. | Όνομα εταιρείας ή οργανισμού."
                    },
                    "registrationNumbers": {
                        "title": "Registration numbers",
                        "type": "array",
                        "description": "One or more Cyprus registration numbers, each looked up separately. Accepts any format: 'HE 6771', 'HE6771' or just '6771'. A bare number matches that number across EVERY organisation type (a limited company HE, a business name EE, an overseas company AE...), so include the letter prefix when you want just one type. | Αριθμοί εγγραφής, π.χ. 'ΗΕ 6771'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "startsWith",
                            "endsWith",
                            "soundsLike"
                        ],
                        "type": "string",
                        "description": "How the company name is matched. 'Starts with' is the register's default and the most reliable. 'Sounds like' uses the register's own phonetic index, which is narrow - it will not behave like a general fuzzy search.",
                        "default": "startsWith"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum organisation records to export. A company that has traded under several names is listed once per former name in the register; those are merged into a single record here, with the former names kept on it, so you are never charged twice for the same company.",
                        "default": 100
                    },
                    "language": {
                        "title": "Result language",
                        "enum": [
                            "en",
                            "el",
                            "tr"
                        ],
                        "type": "string",
                        "description": "Language for labels and values the register translates - organisation type, status and officer positions. Company names and addresses are returned exactly as the register holds them, which for older Cypriot files is Greek regardless of this setting.",
                        "default": "en"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (optional)",
                        "type": "object",
                        "description": "Leave this off. The register accepts ordinary requests and a normal run does not need a proxy, so you should not pay for one. It is here only for users running many searches in parallel from shared addresses.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
