# PEGELONLINE Water Levels Scraper (`parseforge/pegelonline-water-levels-scraper`) Actor

Pull live water levels from the WSV PEGELONLINE gauge network across Germany. Each record carries the station name, water body, current level in centimeters, measurement timestamp, gauge zero datum, and coordinates. Ideal for flood monitoring, hydrology research, and shipping logistics.

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

## Pricing

from $7.50 / 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)

## 🌊 PEGELONLINE Water Levels Scraper

> 🚀 **Export Germany's live river gauge readings in one run.** Pull current water levels from the full WSV PEGELONLINE network of 700+ active stations.

> 🕒 **Last updated:** 2026-06-08 · **📊 Up to 16 fields** per record · live measurements · national coverage

Turn the official WSV PEGELONLINE service into clean, structured records you can drop into a flood dashboard, a hydrology model, or a shipping planner. Every record is one gauge station with its current water level, the water body it sits on, when the reading was taken, the gauge zero datum, and exact coordinates.

Coverage is the live German federal waterway gauge network as PEGELONLINE publishes it: stations on the Rhein, Elbe, Donau, Weser, Aller, and many more rivers, canals, and tidal reaches, each reporting its latest water level in centimeters. The Actor keeps only stations that actually publish a water-level reading, so you never get empty rows for sensors that measure other things.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Flood and emergency response teams | Track rising levels across rivers in one pass |
| Hydrologists and researchers | Snapshot the national gauge network on a schedule |
| Inland shipping and logistics planners | Watch fairway depths on key waterways |
| Civic and environmental developers | Power maps, alerts, and open-data apps |

### 📋 What the PEGELONLINE Water Levels Scraper does

This Actor calls the public WSV PEGELONLINE REST service and returns one clean record per gauge station that reports a water level:

- **Station identity** — name, UUID, official station number, operating agency, and river kilometer.
- **Location** — water body name plus latitude and longitude.
- **Current reading** — water level value, unit, the exact measurement timestamp, and trend states.
- **Reference datum** — gauge zero value, its unit, and the date it became valid.

You can filter by station name or by water body, control how many records come back, and every record carries a `scrapedAt` timestamp.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `station` | string | Optional. Keep only stations whose name contains this text, case-insensitive. For example `Celle`. Leave empty for all stations. |
| `water` | string | Optional. Keep only stations on a water body whose name contains this text, case-insensitive. For example `RHEIN` or `ELBE`. Leave empty for all water bodies. |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |

**Example 1 — every gauge on the Rhein**
```json
{
    "water": "RHEIN",
    "maxItems": 100
}
````

**Example 2 — a single named station**

```json
{
    "station": "DRESDEN",
    "maxItems": 5
}
```

> ⚠️ **Good to Know:** Station and water body names come from PEGELONLINE in German and may include letters with umlauts (for example `KÖLN`). Filters use a plain text match, so type the name as the source spells it. Leave both filters empty to pull the entire active network.

### 📊 Output

Each record looks like this:

| Field | Description |
|---|---|
| 📌 `stationName` | Full station name |
| 🆔 `uuid` | PEGELONLINE station UUID |
| 🔢 `number` | Official station number |
| 🌊 `waterBody` | River, canal, or waterway name |
| 🏛 `agency` | Operating agency |
| 📍 `km` | River kilometer of the station |
| 🧭 `latitude` | Station latitude |
| 🧭 `longitude` | Station longitude |
| 📏 `waterLevel` | Current water level value |
| 📐 `unit` | Level unit (usually cm) |
| 📅 `measuredAt` | Timestamp of the reading |
| 📈 `trendMnwMhw` | State versus mean low/high water |
| 📈 `trendNswHsw` | State versus lowest/highest navigable water |
| 🪧 `gaugeZero` | Gauge zero datum value |
| 📐 `gaugeZeroUnit` | Datum reference unit |
| 🗓 `gaugeZeroValidFrom` | Date the datum became valid |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — Konstanz**

```json
{
    "stationName": "KONSTANZ-RHEIN",
    "uuid": "e020e651-e422-46d3-ae28-34887c5a4a8e",
    "number": "3329",
    "waterBody": "RHEIN",
    "agency": "REGIERUNGSPRÄSIDIUM FREIBURG",
    "km": 0.5,
    "latitude": 47.667889,
    "longitude": 9.172858,
    "waterLevel": 315,
    "unit": "cm",
    "measuredAt": "2026-06-08T23:45:00+02:00",
    "trendMnwMhw": "unknown",
    "trendNswHsw": "unknown",
    "gaugeZero": null,
    "gaugeZeroUnit": null,
    "gaugeZeroValidFrom": null,
    "scrapedAt": "2026-06-08T22:08:01.708Z",
    "error": null
}
```

**Real sample — Basel**

```json
{
    "stationName": "BASEL-RHEINHALLE",
    "uuid": "94f6eff1-4f3f-4850-82e0-a086198e9ffd",
    "number": "2310010",
    "waterBody": "RHEIN",
    "agency": "BUNDESAMT FÜR UMWELT CH",
    "km": 164.3,
    "latitude": 47.559486,
    "longitude": 7.616666,
    "waterLevel": 547,
    "unit": "cm",
    "measuredAt": "2026-06-08T23:50:00+02:00",
    "trendMnwMhw": "unknown",
    "trendNswHsw": "normal",
    "gaugeZero": 240,
    "gaugeZeroUnit": "mü.M.",
    "gaugeZeroValidFrom": "2010-02-01",
    "scrapedAt": "2026-06-08T22:08:01.764Z",
    "error": null
}
```

**Real sample — Rheinweiler**

```json
{
    "stationName": "RHEINWEILER",
    "uuid": "06b978dd-8c4d-48ac-a0c8-2c16681ed281",
    "number": "23300130",
    "waterBody": "RHEIN",
    "agency": "STANDORT FREIBURG",
    "km": 186.2,
    "latitude": 47.711059,
    "longitude": 7.529275,
    "waterLevel": 224,
    "unit": "cm",
    "measuredAt": "2026-06-09T00:00:00+02:00",
    "trendMnwMhw": "normal",
    "trendNswHsw": "unknown",
    "gaugeZero": 217.291,
    "gaugeZeroUnit": "m. ü. NHN",
    "gaugeZeroValidFrom": "2018-11-01",
    "scrapedAt": "2026-06-08T22:08:01.790Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One clean record per station, ready for a database or a map.
- Only stations with a real water-level reading are returned, so no empty rows.
- Coordinates included on every record for instant geo plotting.
- Gauge zero datum included where the source provides it, for absolute elevation work.
- No account, no key, and no login required.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Coordinates included | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Yes | None on your side |
| Reading the PEGELONLINE web map by hand | Hours | Inconsistent | Manual | Constant |
| Writing your own API client | Days | Depends | Manual | You own the upkeep |

### 🚀 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 PEGELONLINE Water Levels Scraper.
3. Optionally set a `station` or `water` filter to narrow the network.
4. Set `maxItems` to the number of records you want.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Flood and emergency response

| Goal | How this helps |
|---|---|
| Spot rising rivers early | Pull current levels across a basin in one run |
| Brief field teams | Share station name, level, and coordinates |

#### Inland shipping and logistics

| Goal | How this helps |
|---|---|
| Plan barge routes | Watch levels on the Rhein, Elbe, and key canals |
| Anticipate draft limits | Track gauge readings against gauge zero |

#### Research and modeling

| Goal | How this helps |
|---|---|
| Build a hydrology dataset | Snapshot the national network on a schedule |
| Calibrate flow models | Combine level, datum, and coordinates |

#### Civic and environmental apps

| Goal | How this helps |
|---|---|
| Power a public level map | Feed it station coordinates and readings |
| Send alert notifications | Trigger on a level threshold per station |

### 🔌 Automating PEGELONLINE Water Levels Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route records into sheets or databases.
- **Slack** to post an alert when a run finishes.
- **Airbyte** to load results into a warehouse.
- **GitHub** Actions to schedule periodic snapshots.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research:** study how water levels move across a basin over time.
- **Personal:** watch the river near your home before a paddling trip.
- **Non-profit:** power a community flood-awareness resource.
- **Experimentation:** prototype a hydrology app without writing a scraper.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to rank stations by level, group them by water body, or flag readings above a threshold.

### ❓ Frequently Asked Questions

**Do I need a PEGELONLINE or WSV account?**
No. The Actor reads the public PEGELONLINE REST service, which needs no login.

**Do I need an API key?**
No key is required.

**What does each record represent?**
One gauge station and its most recent water-level reading.

**Which stations are included?**
Only stations that publish a water-level (W) timeseries with a current reading. Stations that measure only other things are skipped.

**What unit is the water level in?**
Most stations report in centimeters. The exact unit is in the `unit` field.

**What is gauge zero?**
It is the reference elevation the gauge measures from. The value and its reference unit are in `gaugeZero` and `gaugeZeroUnit`. Some stations do not publish it, so those fields can be null.

**How do I filter by river?**
Use the `water` filter, for example `RHEIN` or `ELBE`. Names are in German as PEGELONLINE spells them.

**Why did my station filter return nothing?**
The match is literal. If the station name uses an umlaut, such as `KÖLN`, type it exactly as the source does, or leave the filter empty and browse the full list.

**How fresh is the data?**
Each run pulls live from PEGELONLINE, so it reflects the latest published readings at run time.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot the network on any cadence.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into any app, database, or workflow you already run.

### 🔗 Recommended Actors

- [Have I Been Pwned Breaches Catalog Scraper](https://apify.com/parseforge)
- More reference and open-data Actors in the [ParseForge collection](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 WSV, GDWS, or PEGELONLINE. Only publicly available data is collected.

# Actor input Schema

## `station` (type: `string`):

Optional. Keep only stations whose name contains this text, case-insensitive. For example 'KOLN' or 'Celle'. Leave empty to return every station.

## `water` (type: `string`):

Optional. Keep only stations on a water body whose name contains this text, case-insensitive. For example 'RHEIN', 'ELBE', or 'ALLER'. Leave empty for all water bodies.

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

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

## Actor input object example

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

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/pegelonline-water-levels-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 = { "maxItems": 10 }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PEGELONLINE Water Levels Scraper",
        "description": "Pull live water levels from the WSV PEGELONLINE gauge network across Germany. Each record carries the station name, water body, current level in centimeters, measurement timestamp, gauge zero datum, and coordinates. Ideal for flood monitoring, hydrology research, and shipping logistics.",
        "version": "0.1",
        "x-build-id": "rYTW5prmHn9IdSLFL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~pegelonline-water-levels-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-pegelonline-water-levels-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~pegelonline-water-levels-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-pegelonline-water-levels-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~pegelonline-water-levels-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-pegelonline-water-levels-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": {
                    "station": {
                        "title": "Station name filter",
                        "type": "string",
                        "description": "Optional. Keep only stations whose name contains this text, case-insensitive. For example 'KOLN' or 'Celle'. Leave empty to return every station."
                    },
                    "water": {
                        "title": "Water body filter",
                        "type": "string",
                        "description": "Optional. Keep only stations on a water body whose name contains this text, case-insensitive. For example 'RHEIN', 'ELBE', or 'ALLER'. Leave empty for all water bodies."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```