# Luxembourg Open Data Scraper (`parseforge/luxembourg-open-data-scraper`) Actor

Pull open government datasets from Luxembourg data.public.lu. Each record returns the title, description, publishing organization, tags, license, update frequency, and every attached resource with its type and link. Filter by search query, tag, or organization for civic and research work.

- **URL**: https://apify.com/parseforge/luxembourg-open-data-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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)

## 🇱🇺 Luxembourg Open Data Scraper

> 🚀 **Export Luxembourg open government datasets in seconds.** Turn the national data portal data.public.lu into a clean feed of 2,500+ datasets with their files, organizations, tags and licenses.

> 🕒 **Last updated:** 2026-06-05 · **📊 29 fields** per record · 2,500+ public datasets · Full national open data catalog

Luxembourg's official open data portal, data.public.lu, publishes thousands of datasets from ministries, municipalities, public services and certified organizations. This Actor reads the portal's official uData API and returns one clean record per dataset, including every downloadable resource attached to it.

**Coverage:** the full public catalog of data.public.lu, covering mobility, weather, environment, geography, statistics, budgets and more. Filter by free text search, by tag, or by organization to focus on exactly the datasets you need.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Data journalists and researchers | Discovering and tracking public datasets |
| Civic tech and GovTech builders | Feeding open data into apps and dashboards |
| Analysts and data engineers | Building catalogs of available data sources |
| Open data and transparency teams | Monitoring publication and update activity |

### 📋 What the Luxembourg Open Data Scraper does

This Actor queries the data.public.lu uData API and collects open government datasets. For each dataset it returns the title, description, publishing organization, tags, license, update frequency, creation and modification dates, popularity metrics, and the full list of attached resources with their formats, sizes and download links.

You can run it with no filters to list the most recent datasets, or narrow the catalog using a search query, a tag, or an organization. Slugs for organizations are resolved automatically to the identifier the API expects.

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

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `query` | string | No | Full text search across dataset titles and descriptions. |
| `tag` | string | No | Tag slug to filter datasets (e.g. `transport`, `mobility`). |
| `organization` | string | No | Organization slug or 24 character identifier. |
| `pageSize` | integer | No | Datasets requested per API page (1 to 100, default 20). |
| `maxItems` | integer | No | Free users limited to 10 items. Paid users up to 1,000,000. |

**Example 1: latest datasets**

```json
{
  "maxItems": 20,
  "pageSize": 20
}
````

**Example 2: filter by tag and organization**

```json
{
  "tag": "transport",
  "organization": "cfl-mobility",
  "maxItems": 50
}
```

> ⚠️ **Good to Know:** leave all filters empty to browse the latest datasets. The `organization` field accepts a slug such as `cfl-mobility`, which is resolved to its internal identifier automatically. Tags must match the exact slug shown on data.public.lu.

### 📊 Output

Each record represents one dataset and includes its resources list.

| Field | Description |
|---|---|
| 🖼 `imageUrl` | Logo of the publishing organization |
| 📌 `title` | Dataset title |
| 🔗 `datasetUrl` | Public dataset page on data.public.lu |
| 🆔 `id` | Dataset identifier |
| 🏷 `slug` | Dataset slug |
| 📝 `description` | Full dataset description |
| 🏢 `organization` | Publishing organization name |
| 📜 `license` | License code (e.g. cc-by, cc-zero) |
| 🔄 `frequency` | Declared update frequency |
| 🏷 `tags` | Array of dataset tags |
| 🌍 `spatialGranularity` | Spatial granularity (e.g. country) |
| 🗺 `spatialZones` | Spatial zones covered |
| 📅 `createdAt` | Creation timestamp |
| 🕒 `lastModified` | Last modification timestamp |
| 👁 `views` | View count metric |
| ♻️ `reuses` | Reuse count metric |
| ⭐ `qualityScore` | Portal quality score (0 to 1) |
| 📦 `formats` | Distinct resource formats |
| #️⃣ `resourceCount` | Number of attached resources |
| 📂 `resources` | Array of resources (title, format, size, url, downloadUrl, dates) |
| 🕒 `scrapedAt` | When the record was collected |

**Sample records (real output):**

```json
{
  "imageUrl": "https://download.data.public.lu/avatars/ea/e64daed3f141978063c4260a1e42a4-original.jpg",
  "title": "FLEX Carsharing by CFL",
  "datasetUrl": "https://data.public.lu/fr/datasets/flex-carsharing-by-cfl-1/",
  "organization": "CFL Mobility",
  "license": "cc-by",
  "frequency": "continuous",
  "tags": ["carsharing", "cfl", "flex", "its", "mobility"],
  "formats": ["csv"],
  "resourceCount": 1,
  "views": 115,
  "lastModified": "2026-06-05T16:41:12.344000+00:00"
}
```

```json
{
  "imageUrl": "https://download.data.public.lu/avatars/6b/cc58718d244e64bf1b7fbf3e91f7cb-original.png",
  "title": "Aerodrome Reports and Forecasts for Luxembourg-Airport (ELLX)",
  "datasetUrl": "https://data.public.lu/fr/datasets/aerodrome-reports-and-forecasts-for-luxembourg-airport-ellx/",
  "organization": "MeteoLux",
  "license": "cc-zero",
  "frequency": "continuous",
  "tags": ["climat", "meteorology", "mobility", "transport", "waether"],
  "formats": ["csv"],
  "resourceCount": 3,
  "views": 122,
  "lastModified": "2026-06-05T16:32:21.745000+00:00"
}
```

```json
{
  "imageUrl": "https://download.data.public.lu/avatars/6b/cc58718d244e64bf1b7fbf3e91f7cb-original.png",
  "title": "Present weather condition at Luxembourg-Airport (ELLX) decoded from METAR message",
  "datasetUrl": "https://data.public.lu/fr/datasets/present-weather-condition-at-luxembourg-airport-ellx-decoded-from-metar-message/",
  "organization": "MeteoLux",
  "license": "cc-zero",
  "frequency": "continuous",
  "tags": ["climat", "meteorology", "weather"],
  "formats": ["csv"],
  "resourceCount": 4,
  "views": 118,
  "lastModified": "2026-06-05T16:32:13.176000+00:00"
}
```

### ✨ Why choose this Actor

- Reads the official data.public.lu uData API, so results stay close to the source.
- One clean record per dataset, with the full resources list attached.
- Filter by search query, tag, or organization, with automatic slug resolution.
- Includes organization logos, licenses, update frequency and quality scores.
- No login or API key required to run.

### 📈 How it compares to alternatives

| Approach | Setup | Resources included | Filtering | Maintenance |
|---|---|---|---|---|
| This Actor | None, run and go | Yes, full list | Query, tag, organization | Managed |
| Manual portal browsing | High, page by page | Manual copy | Limited | Constant |
| Raw API scripting | Coding required | You build it | You build it | You own it |

### 🚀 How to use

1. Sign up for a free Apify account using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Luxembourg Open Data Scraper in the Apify Console.
3. Leave filters empty for the latest datasets, or set a query, tag, or organization.
4. Set how many datasets you want with Max Items, then click Start.
5. Collect your results once the run finishes.

### 💼 Business use cases

#### Data discovery and cataloging

| Goal | How this helps |
|---|---|
| Build a searchable catalog | Pull titles, tags and organizations in one pass |
| Track new publications | Sort by creation and modification dates |

#### Civic tech and applications

| Goal | How this helps |
|---|---|
| Feed open data into apps | Resource download links are included per dataset |
| Surface official sources | Organization names and pages travel with each record |

#### Research and journalism

| Goal | How this helps |
|---|---|
| Find datasets by topic | Search by query or tag across the catalog |
| Cite licensing clearly | License codes are returned for every dataset |

#### Monitoring and reporting

| Goal | How this helps |
|---|---|
| Watch update activity | Frequency and last modified timestamps included |
| Measure popularity | View and reuse metrics ship with each record |

### 🔌 Automating Luxembourg Open Data Scraper

Connect this Actor to the tools you already use:

- **Make** and **Zapier** for no code workflows.
- **Slack** to post new datasets to a channel.
- **Airbyte** to sync results into a warehouse.
- **GitHub** Actions to schedule recurring runs.
- **Google Drive** to archive results automatically.

### 🌟 Beyond business use cases

- **Research:** study how Luxembourg publishes and updates open data over time.
- **Personal:** find public transport, weather or mapping data for hobby projects.
- **Non-profit:** support transparency and civic engagement initiatives.
- **Experimentation:** prototype dashboards and data apps on real public data.

### 🤖 Ask an AI assistant

Bring your results into your favorite assistant:

- [ChatGPT](https://chat.openai.com)
- [Claude](https://claude.ai)
- [Perplexity](https://www.perplexity.ai)
- [Microsoft Copilot](https://copilot.microsoft.com)

### ❓ Frequently Asked Questions

**Do I need an API key?**
No. The data.public.lu uData API is public and this Actor needs no key.

**What is the data source?**
The official Luxembourg open data portal at data.public.lu.

**How many datasets are available?**
The catalog holds 2,500+ public datasets at the time of writing.

**Can I filter by topic?**
Yes. Use the search query or a tag slug to narrow the results.

**Can I filter by publisher?**
Yes. Provide an organization slug or identifier in the organization field.

**Does each record include the data files?**
Yes. Every dataset carries a resources list with formats and download links.

**What languages are dataset titles in?**
Mostly French and English, as published on the portal.

**How current is the data?**
Each run reads the portal live, so results reflect the catalog at run time.

**Is there a limit on results?**
Free runs return up to 10 datasets. Paid plans go much higher.

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

### 🔌 Integrate with any app

Results are available through the Apify API and storage, so you can push them into databases, spreadsheets, BI tools, or any service that speaks HTTP.

### 🔗 Recommended Actors

- [OpenChargeMap EV Station Scraper](https://apify.com/parseforge)
- [OpenAQ Air Quality Scraper](https://apify.com/parseforge)
- [Estonia Business Register Scraper](https://apify.com/parseforge)
- [EU Safety Gate RAPEX Scraper](https://apify.com/parseforge)
- [DBnomics Economic Series 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 Luxembourg government or data.public.lu. Only publicly available data collected.

# Actor input Schema

## `query` (type: `string`):

Optional full text search across dataset titles and descriptions (e.g. "transport", "budget", "environment"). Leave empty to list the most recent datasets.

## `tag` (type: `string`):

Optional tag slug to filter datasets (e.g. "transport", "mobility", "environnement"). Use the exact tag slug shown on data.public.lu.

## `organization` (type: `string`):

Optional organization. Accepts an organization slug (e.g. "cfl-mobility") or its 24 character identifier. Slugs are resolved automatically.

## `pageSize` (type: `integer`):

Number of datasets requested per API page. Larger values fetch more datasets per request.

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

Free users: limited to 10 items (preview). Paid users: optional, max 1,000,000.

## Actor input object example

```json
{
  "pageSize": 20,
  "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 = {
    "pageSize": 20,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/luxembourg-open-data-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 = {
    "pageSize": 20,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/luxembourg-open-data-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 '{
  "pageSize": 20,
  "maxItems": 10
}' |
apify call parseforge/luxembourg-open-data-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Luxembourg Open Data Scraper",
        "description": "Pull open government datasets from Luxembourg data.public.lu. Each record returns the title, description, publishing organization, tags, license, update frequency, and every attached resource with its type and link. Filter by search query, tag, or organization for civic and research work.",
        "version": "0.1",
        "x-build-id": "4gWL03GR1FbEauTmB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~luxembourg-open-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-luxembourg-open-data-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~luxembourg-open-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-luxembourg-open-data-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~luxembourg-open-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-luxembourg-open-data-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": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Optional full text search across dataset titles and descriptions (e.g. \"transport\", \"budget\", \"environment\"). Leave empty to list the most recent datasets."
                    },
                    "tag": {
                        "title": "Tag",
                        "type": "string",
                        "description": "Optional tag slug to filter datasets (e.g. \"transport\", \"mobility\", \"environnement\"). Use the exact tag slug shown on data.public.lu."
                    },
                    "organization": {
                        "title": "Organization",
                        "type": "string",
                        "description": "Optional organization. Accepts an organization slug (e.g. \"cfl-mobility\") or its 24 character identifier. Slugs are resolved automatically."
                    },
                    "pageSize": {
                        "title": "Page size",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of datasets requested per API page. Larger values fetch more datasets per request."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```