# UK Flood and River Monitoring Scraper (`parseforge/uk-flood-river-monitoring-scraper`) Actor

Tap into the UK Environment Agency flood network to pull river monitoring stations and live warnings. Returns station reference, river, town, coordinates, parameter, unit, and the latest reading with timestamp. Filter by parameter, river, or town. Great for flood risk and hydrology work.

- **URL**: https://apify.com/parseforge/uk-flood-river-monitoring-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, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

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

## 🌊 UK Flood and River Monitoring Scraper

> 🚀 **Pull live UK river levels and flood warnings in seconds.** Get the latest reading from thousands of Environment Agency monitoring stations plus every active flood alert across England.

> 🕒 **Last updated:** 2026-06-05 · **📊 18 fields** per station record · National coverage (England) · Keyless open data

Track water levels, flow, and rainfall from the UK Environment Agency real-time flood-monitoring network, and watch flood warnings and alerts as they are raised. Each monitoring station returns its river, label, town, catchment, coordinates, measured parameter, unit, and the most recent reading with its timestamp. Each flood warning returns its area, severity, river or sea, county, and the full public message.

Coverage spans the Environment Agency station network across England, including river level gauges, flow gauges, and tipping-bucket rainfall gauges, along with live flood alerts, flood warnings, and severe flood warnings published through the official open service.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Hydrologists and environmental analysts | Track river levels and flood risk over time |
| Insurance and risk teams | Monitor flood exposure by area and severity |
| Developers and data engineers | Feed live water data into apps and dashboards |
| Researchers and journalists | Study flooding patterns and report on events |
| Emergency planners and local councils | Stay aware of active alerts in their region |

### 📋 What the UK Flood and River Monitoring Scraper does

This Actor reads the UK Environment Agency Flood-Monitoring service and turns it into clean, structured records. In `stations` mode it lists monitoring stations and resolves the latest reading per station, so you get the current water level, flow, or rainfall value together with the reading time. In `floods` mode it lists active flood warnings and alerts with their severity and message. You can narrow station results by measured parameter, river name, or town.

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

### ⚙️ Input

The Actor accepts a small set of options. Pick a mode, set how many records you want, and add optional filters for station searches.

| Field | Type | Description |
|---|---|---|
| `mode` | string | `stations` for monitoring stations and latest readings, or `floods` for flood warnings and alerts. |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |
| `parameter` | string | Filter stations by measured parameter such as `level`, `flow`, or `rainfall`. Stations mode only. |
| `river` | string | Filter stations by exact river name, for example `River Thames`. Stations mode only. |
| `town` | string | Filter stations by town, for example `Reading`. Stations mode only. |

Example 1: latest river levels for the River Thames

```json
{
    "mode": "stations",
    "parameter": "level",
    "river": "River Thames",
    "maxItems": 25
}
````

Example 2: current flood warnings

```json
{
    "mode": "floods",
    "maxItems": 50
}
```

> ⚠️ **Good to Know:** The number of flood warnings depends on real conditions. During calm weather there may be only a handful of active alerts, while storms can raise many. Station results are always available because the gauge network reports continuously.

### 📊 Output

Each station (or flood warning) becomes one record. Station records use the schema below.

| Field | Description |
|---|---|
| 🏷️ `recordType` | `station` or `flood`. |
| 🔖 `stationReference` | Unique station code from the Environment Agency. |
| 📌 `label` | Human readable station name. |
| 🌊 `riverName` | River the station measures. |
| 🏘️ `town` | Nearest town. |
| 🗺️ `catchmentName` | Catchment the station belongs to. |
| 📍 `lat` / `long` | Station coordinates. |
| 📐 `parameter` | Measured parameter such as level, flow, or rainfall. |
| 🏷️ `parameterName` | Friendly parameter name. |
| 📏 `unitName` | Unit of the reading, for example mASD or mm. |
| 📈 `latestValue` | Most recent reading value. |
| 🕒 `latestReadingDateTime` | Timestamp of the latest reading. |
| 🟢 `status` | Station status, for example Active. |
| 📅 `dateOpened` | Date the station opened. |
| 🔗 `stationUrl` | Source page for the station. |
| 🕒 `scrapedAt` | When the record was collected. |
| ❌ `error` | Null on success. |

Three real sample records:

```json
[
  {
    "recordType": "station",
    "stationReference": "1029TH",
    "label": "Bourton Dickler",
    "riverName": "River Dikler",
    "town": "Little Rissington",
    "catchmentName": "Cotswolds",
    "lat": 51.874767,
    "long": -1.740083,
    "parameter": "level",
    "parameterName": "Water Level",
    "unitName": "mASD",
    "latestValue": -0.354,
    "latestReadingDateTime": "2026-06-05T16:15:00Z",
    "status": "Active",
    "dateOpened": "1994-01-01",
    "stationUrl": "http://environment.data.gov.uk/flood-monitoring/id/stations/1029TH",
    "scrapedAt": "2026-06-05T17:04:27.897Z",
    "error": null
  },
  {
    "recordType": "station",
    "stationReference": "E2043",
    "label": "Surfleet Sluice",
    "riverName": "River Glen",
    "town": "Surfleet Seas End",
    "catchmentName": "Welland",
    "lat": 52.845991,
    "long": -0.100848,
    "parameter": "level",
    "parameterName": "Water Level",
    "unitName": "mASD",
    "latestValue": 0.851,
    "latestReadingDateTime": "2026-06-05T16:30:00Z",
    "status": "Active",
    "dateOpened": "1992-01-01",
    "stationUrl": "http://environment.data.gov.uk/flood-monitoring/id/stations/E2043",
    "scrapedAt": "2026-06-05T17:04:29.832Z",
    "error": null
  },
  {
    "recordType": "station",
    "stationReference": "52119",
    "label": "Gaw Bridge",
    "riverName": "River Parrett",
    "town": "Kingsbury Episcopi",
    "catchmentName": "Parrett, Brue and West Somerset Streams",
    "lat": 50.976043,
    "long": -2.793549,
    "parameter": "level",
    "parameterName": "Water Level",
    "unitName": "mASD",
    "latestValue": 0.44,
    "latestReadingDateTime": "2026-06-05T16:30:00Z",
    "status": "Active",
    "dateOpened": "1997-01-01",
    "stationUrl": "http://environment.data.gov.uk/flood-monitoring/id/stations/52119",
    "scrapedAt": "2026-06-05T17:04:30.039Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

- Official open data from the UK Environment Agency, no key needed.
- Latest reading resolved per station, not just the station list.
- Two modes in one tool, stations and flood warnings.
- Clean flat records, one row per station or warning.
- Filter stations by parameter, river, or town.

### 📈 How it compares to alternatives

| Approach | Latest reading per station | Flood warnings | Clean structured rows | Filters |
|---|---|---|---|---|
| This Actor | Yes | Yes | Yes | Parameter, river, town |
| Raw API by hand | Manual per station | Separate calls | No, nested data | Limited |
| Generic web scraper | No | No | Often messy | No |

### 🚀 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 UK Flood and River Monitoring Scraper.
3. Choose `stations` or `floods` mode and set `maxItems`.
4. Add optional station filters for parameter, river, or town.
5. Run the Actor and collect your records from the dataset.

### 💼 Business use cases

#### Insurance and risk

| Need | How this helps |
|---|---|
| Flood exposure by area | Pull active warnings with severity and county. |
| Trend monitoring | Sample station readings over time for risk models. |

#### Environmental analysis

| Need | How this helps |
|---|---|
| River level studies | Track level and flow values across catchments. |
| Rainfall context | Combine rainfall gauges with river readings. |

#### Public sector and planning

| Need | How this helps |
|---|---|
| Local alerting | Watch warnings raised in a given region. |
| Reporting | Build situational summaries from live data. |

#### Apps and dashboards

| Need | How this helps |
|---|---|
| Live water widget | Feed station readings into a map or panel. |
| Notifications | Trigger messages when warnings appear. |

### 🔌 Automating UK Flood and River Monitoring Scraper

Connect this Actor to the tools you already use:

- **Make** and **Zapier** to route records into other apps.
- **Slack** to post new flood warnings to a channel.
- **Airbyte** to sync records into a warehouse.
- **GitHub** Actions to schedule pulls.
- **Google Drive** to archive snapshots.

### 🌟 Beyond business use cases

- **Research:** study flooding frequency and river behavior.
- **Personal:** keep an eye on a local river near your home.
- **Non-profit:** support community flood resilience projects.
- **Experimentation:** practice building data pipelines with live open data.

### 🤖 Ask an AI assistant

Paste your records into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Copilot](https://copilot.microsoft.com) and ask it to summarize current flood risk, rank stations by level, or draft an alert.

### ❓ Frequently Asked Questions

**Is the data official?**
Yes. It comes from the UK Environment Agency real-time flood-monitoring service.

**Do I need an API key?**
No. The service is open and keyless.

**What does stations mode return?**
Monitoring stations with river, town, coordinates, parameter, unit, and the latest reading.

**What does floods mode return?**
Active flood alerts and warnings with severity, area, and the full public message.

**Why do I sometimes see few flood warnings?**
The count reflects real conditions. In calm weather there may be only a few or none.

**Can I filter stations?**
Yes, by parameter, river name, or town.

**What parameters are available?**
Commonly level, flow, and rainfall, depending on the station.

**What is the unit mASD?**
Meters above stage datum, a common reference for river level gauges.

**How current are the readings?**
Most gauges report at regular intervals, often every 15 minutes.

**Does this cover Scotland and Wales?**
The service covers England. Other nations run separate services.

**How many records can I get?**
Free plans return up to 10. Paid plans return many more.

**Is this affiliated with the Environment Agency?**
No. It is an independent tool that reads public open data.

### 🔌 Integrate with any app

Use the Apify API and the dataset to send records into spreadsheets, databases, BI tools, or custom apps.

### 🔗 Recommended Actors

- [ParseForge collection](https://apify.com/parseforge) for more open data and web scrapers.
- Weather and environmental data Actors for added context.
- Geocoding Actors to enrich station coordinates.

> 💡 **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 UK Environment Agency. Only publicly available data collected. Contains public sector information licensed under the Open Government Licence v3.0.

# Actor input Schema

## `mode` (type: `string`):

Choose what to collect. 'stations' returns river, level and rainfall monitoring stations with their latest reading. 'floods' returns active flood warnings and alerts.

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

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

## `parameter` (type: `string`):

Filter stations by measured parameter. Only used in 'stations' mode.

## `river` (type: `string`):

Filter stations by exact river name, for example 'River Thames'. Only used in 'stations' mode.

## `town` (type: `string`):

Filter stations by town, for example 'Reading'. Only used in 'stations' mode.

## Actor input object example

```json
{
  "mode": "stations",
  "maxItems": 10,
  "parameter": "",
  "river": "",
  "town": ""
}
```

# 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/uk-flood-river-monitoring-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/uk-flood-river-monitoring-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/uk-flood-river-monitoring-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UK Flood and River Monitoring Scraper",
        "description": "Tap into the UK Environment Agency flood network to pull river monitoring stations and live warnings. Returns station reference, river, town, coordinates, parameter, unit, and the latest reading with timestamp. Filter by parameter, river, or town. Great for flood risk and hydrology work.",
        "version": "0.1",
        "x-build-id": "wWv3iKftsJwmiy2Ij"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~uk-flood-river-monitoring-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-uk-flood-river-monitoring-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~uk-flood-river-monitoring-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-uk-flood-river-monitoring-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~uk-flood-river-monitoring-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-uk-flood-river-monitoring-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "stations",
                            "floods"
                        ],
                        "type": "string",
                        "description": "Choose what to collect. 'stations' returns river, level and rainfall monitoring stations with their latest reading. 'floods' returns active flood warnings and alerts.",
                        "default": "stations"
                    },
                    "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"
                    },
                    "parameter": {
                        "title": "Parameter (stations mode)",
                        "enum": [
                            "",
                            "level",
                            "flow",
                            "rainfall",
                            "wind",
                            "temperature"
                        ],
                        "type": "string",
                        "description": "Filter stations by measured parameter. Only used in 'stations' mode.",
                        "default": ""
                    },
                    "river": {
                        "title": "River name (stations mode)",
                        "type": "string",
                        "description": "Filter stations by exact river name, for example 'River Thames'. Only used in 'stations' mode.",
                        "default": ""
                    },
                    "town": {
                        "title": "Town (stations mode)",
                        "type": "string",
                        "description": "Filter stations by town, for example 'Reading'. Only used in 'stations' mode.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
