# Flood Warnings & River Levels Monitor: UK, France, Germany, US (`maliksaid/flood-warnings-monitor`) Actor

River level and flood warning watchlist for your sites. Nearest gauges in England, France, Germany and the US with latest water level, trend, high-water status, NWS flood category and Environment Agency flood warnings. Monitor mode returns only changes.

- **URL**: https://apify.com/maliksaid/flood-warnings-monitor.md
- **Developed by:** [Malik Said](https://apify.com/maliksaid) (community)
- **Categories:** News, Real estate
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 site and gauge statuses

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Flood Warnings & River Levels Monitor: UK, France, Germany, US

This Actor watches river levels and flood warnings near your sites. You give it a list of places with coordinates. For each place it returns the nearest river gauges, the latest water level, the trend and any active flood warning. It covers England, France, Germany and the United States in one table.

Insurers, property and facility managers, logistics planners, utilities and newsrooms use it to watch warehouses, plants, offices, bridges and supply routes.

### What it covers

| Country | Official source | Level and trend | High-water status | Flood warnings |
|---|---|---|---|---|
| England | Environment Agency real-time flood monitoring API | Yes | Against the station's typical range | Flood alerts, flood warnings and severe flood warnings near the site |
| France | Hub'Eau hydrometrie API (eaufrance) | Yes | No | No |
| Germany | PEGELONLINE, Federal Waterways and Shipping Administration | Yes, federal waterways such as the Rhine, Elbe and Danube | Low, normal or high against mean low and mean high water | No |
| United States | NOAA National Water Prediction Service | Yes | NWS observed flood category | Observed and forecast NWS flood category for each gauge |

Flow (discharge) comes with US and France gauges that report it. England and Germany rows have no flow in this version. Every country gets the 12-hour peak level.

France and Germany have no national flood-warning feed in this Actor. For those countries, use the level, trend and status fields.

A local test run on 21 October 2026 with 40 cities (10 per country) and 5 gauges per site returned 191 rows. Every site had at least one reporting gauge within 25 km.

### What you get

One row per site and gauge.

| Field | Meaning |
|---|---|
| `siteName`, `siteLatitude`, `siteLongitude`, `siteRadiusKm` | Your site and its search radius |
| `country`, `countryCode`, `source` | Country and the official service |
| `gaugeId`, `gaugeName`, `riverName` | The gauge. For US gauges the river is taken from the gauge name |
| `gaugeLatitude`, `gaugeLongitude`, `distanceKm` | Gauge position and distance from your site |
| `level`, `levelUnit` | Latest water level in the source unit: m, mASD or mAOD (England), mm (France), cm (Germany), ft (US) |
| `levelMetres` | The same level in metres. Each gauge has its own datum, so compare a gauge only with itself |
| `levelTime` | Time of the latest reading, UTC |
| `levelChange`, `trend`, `trendWindowHours` | Change over about 3 hours, in the source unit. `rising`, `falling`, `steady` (under 2 cm) or `unknown` |
| `levelStatus`, `levelStatusBasis` | `low`, `normal`, `high`, `flood` or `unknown`, and what the status is based on |
| `referenceHighLevel`, `referenceHighLabel` | Top of typical range (England), mean high water MHW (Germany) or minor flood stage (US) |
| `floodCategory`, `forecastFloodCategory`, `forecastLevel`, `forecastTime` | US only. NWS observed and forecast flood category, and the forecast stage |
| `peakLevel12h`, `peakLevelMetres12h`, `peakTime12h` | Highest level in the last 12 hours and when it happened. Shows whether a crest already passed overnight |
| `flow`, `flowUnit`, `flowCubicMetresPerSecond`, `flowTime` | US and France: latest flow (discharge) and its time. Null for England and Germany, and for gauges without a flow series |
| `gaugeUrl` | Link to the gauge on the official service |
| `warningCount`, `highestWarningSeverity`, `warnings` | England flood alerts and warnings within your site radius, most severe first |
| `alertState` | Short summary of the alert state. Monitor mode uses it to find changes |

Fields that a source does not publish are `null`. For example, France rows have no status, and only US rows have flood categories.

Sample record from a test run:

```json
{
    "id": "Carlisle|GB:765045",
    "siteName": "Carlisle",
    "siteLatitude": 54.8925,
    "siteLongitude": -2.9329,
    "siteRadiusKm": 25,
    "country": "England",
    "countryCode": "GB",
    "source": "Environment Agency",
    "gaugeId": "765045",
    "gaugeName": "Denton Holme",
    "riverName": "River Caldew",
    "gaugeLatitude": 54.885739,
    "gaugeLongitude": -2.937513,
    "distanceKm": 0.8,
    "level": 0.282,
    "levelUnit": "m",
    "levelMetres": 0.282,
    "levelTime": "2026-10-21T10:45:00.000Z",
    "levelChange": -0.008,
    "trend": "steady",
    "trendWindowHours": 3,
    "levelStatus": "normal",
    "levelStatusBasis": "Environment Agency typical range for this station",
    "referenceHighLevel": 2.2,
    "referenceHighLabel": "Top of typical range",
    "floodCategory": null,
    "forecastFloodCategory": null,
    "forecastLevel": null,
    "forecastTime": null,
    "gaugeUrl": "https://check-for-flooding.service.gov.uk/station/5042",
    "flow": null,
    "flowUnit": null,
    "flowCubicMetresPerSecond": null,
    "flowTime": null,
    "peakLevel12h": 0.291,
    "peakLevelMetres12h": 0.291,
    "peakTime12h": "2026-10-21T04:30:00.000Z",
    "warningCount": 0,
    "highestWarningSeverity": null,
    "warnings": [],
    "alertState": "level:normal|observed:-|forecast:-|warnings:none",
    "scrapedAt": "2026-10-21T11:24:16.832Z"
}
```

An England warning in the `warnings` list looks like this (from a test run with ended warnings included):

```json
{
    "warningId": "122WAC954",
    "source": "Environment Agency",
    "severity": "Warning no longer in force",
    "severityLevel": 4,
    "description": "North Sea coast at Bridlington",
    "riverOrSea": "North Sea",
    "county": "East Riding of Yorkshire",
    "isTidal": true,
    "timeRaised": "2026-10-20T20:14:45",
    "timeSeverityChanged": "2026-10-20T20:14:00",
    "distanceKm": 2.4,
    "url": "https://check-for-flooding.service.gov.uk/target-area/122WAC954"
}
```

Each warning also has the full `message` text. Warning times are as the Environment Agency publishes them, without a time zone.

### How to use it

1. Add your sites under **Sites to watch**. Each site needs `name`, `latitude` and `longitude`. `radiusKm` is optional.
2. Choose how many gauges per site you want. The default is 3.
3. Run the Actor. Sort the table by `levelStatus`, `trend` or `warningCount`.
4. For alerts, turn on **Monitor mode** and schedule the Actor, for example every hour.

### Change-only alerts (monitor mode)

With monitor mode on, a row is saved only when its alert state changed since the last monitor-mode run with the same state key. The alert state combines:

- the level status (low, normal, high, flood),
- the US observed and forecast flood category,
- the England warnings near the site and their severity.

A change in the trend alone does not create an alert. The first monitor-mode run saves every row as the starting point. A return to normal also creates a row, so you see when a warning ends.

### Input

| Option | Default | Meaning |
|---|---|---|
| Sites to watch | 4 example sites | Your places, each with name, latitude, longitude and optional radiusKm. Up to 100 per run. A run with 40 sites took about 5 minutes |
| Default radius (km) | 25 | Radius for a site without radiusKm. Maximum 100 |
| Gauges per site | 3 | Nearest reporting gauges per site. Maximum 20 |
| Countries | All four | Which national services to read |
| Include ended England warnings | Off | Also list warnings marked "Warning no longer in force" |
| Monitor mode | Off | Save only rows whose alert state changed |
| Monitor state key | `default` | Name of the monitor memory. Use one per watch list |
| Maximum items | 100 | Stop after this many rows. Set 0 for no limit |

A site outside the four countries is skipped with a log message. A site with no reporting gauge and no warning in range saves nothing and costs nothing.

### Pricing

You pay a small fee per run and a fee for each site and gauge row saved. Rows that monitor mode skips cost nothing. See the Pricing tab.

### Related Actor

For earthquakes, tropical cyclones, wildfires, volcanoes and global flood events near your sites, see [Natural Hazards Monitor](https://apify.com/maliksaid/natural-hazards-monitor). It uses the same site and radius input.

### Data sources and use

- England: Environment Agency, Open Government Licence v3.0. This uses Environment Agency flood and river level data from the real-time data API (Beta).
- France: Hub'Eau, eaufrance open data.
- Germany: PEGELONLINE, Federal Waterways and Shipping Administration (WSV), licence DL-DE Zero 2.0.
- United States: NOAA National Water Prediction Service, US government data.
- All sources are public APIs that need no login or key. The Actor sends a small number of spaced requests.
- The Actor collects no personal data.
- Readings are provisional data from the agencies. For official flood advice, follow your national flood service.

### Support

Report a problem in the Issues tab. Include the run link.

# Actor input Schema

## `sites` (type: `array`):

Your assets: a list of places, each with name, latitude, longitude and an optional radiusKm. For each site the Actor returns the nearest river gauges within the radius, one row per site and gauge. England sites also get active Environment Agency flood alerts and warnings. Up to 100 sites per run.

## `defaultRadiusKm` (type: `integer`):

Search radius used for a site that has no radiusKm. Gauges and warnings further away are ignored.

## `gaugesPerSite` (type: `integer`):

How many of the nearest reporting gauges to return for each site. Each gauge is one row.

## `countries` (type: `array`):

Which national services to read. A site is checked only against the countries its radius touches. Leave empty for all four.

## `includeEndedWarnings` (type: `boolean`):

Also list England warnings that the Environment Agency still lists as 'Warning no longer in force'. Off returns only flood alerts, flood warnings and severe flood warnings in force.

## `monitorMode` (type: `boolean`):

Return a site and gauge row only when its alert state changed since the last monitor-mode run with the same state key. The alert state is the level status, the US flood categories and the set of England warnings with their severity. The first run returns every row. Schedule the Actor with this on to get change-only alerts.

## `stateKey` (type: `string`):

Name of the memory that monitor mode uses. Use a different key for each separate watch list.

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

Stop after saving this many rows. The default keeps test runs short and cheap. Set 0 for no limit.

## Actor input object example

```json
{
  "sites": [
    {
      "name": "York riverside warehouse",
      "latitude": 53.959,
      "longitude": -1.0815,
      "radiusKm": 25
    },
    {
      "name": "Paris office",
      "latitude": 48.8566,
      "longitude": 2.3522,
      "radiusKm": 25
    },
    {
      "name": "Cologne depot",
      "latitude": 50.9375,
      "longitude": 6.9603,
      "radiusKm": 25
    },
    {
      "name": "Sacramento plant",
      "latitude": 38.5816,
      "longitude": -121.4944,
      "radiusKm": 25
    }
  ],
  "defaultRadiusKm": 25,
  "gaugesPerSite": 3,
  "countries": [
    "england",
    "france",
    "germany",
    "us"
  ],
  "includeEndedWarnings": false,
  "monitorMode": false,
  "stateKey": "default",
  "maxItems": 100
}
```

# 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 = {
    "sites": [
        {
            "name": "York riverside warehouse",
            "latitude": 53.959,
            "longitude": -1.0815,
            "radiusKm": 25
        },
        {
            "name": "Paris office",
            "latitude": 48.8566,
            "longitude": 2.3522,
            "radiusKm": 25
        },
        {
            "name": "Cologne depot",
            "latitude": 50.9375,
            "longitude": 6.9603,
            "radiusKm": 25
        },
        {
            "name": "Sacramento plant",
            "latitude": 38.5816,
            "longitude": -121.4944,
            "radiusKm": 25
        }
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("maliksaid/flood-warnings-monitor").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 = {
    "sites": [
        {
            "name": "York riverside warehouse",
            "latitude": 53.959,
            "longitude": -1.0815,
            "radiusKm": 25,
        },
        {
            "name": "Paris office",
            "latitude": 48.8566,
            "longitude": 2.3522,
            "radiusKm": 25,
        },
        {
            "name": "Cologne depot",
            "latitude": 50.9375,
            "longitude": 6.9603,
            "radiusKm": 25,
        },
        {
            "name": "Sacramento plant",
            "latitude": 38.5816,
            "longitude": -121.4944,
            "radiusKm": 25,
        },
    ],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("maliksaid/flood-warnings-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "sites": [
    {
      "name": "York riverside warehouse",
      "latitude": 53.959,
      "longitude": -1.0815,
      "radiusKm": 25
    },
    {
      "name": "Paris office",
      "latitude": 48.8566,
      "longitude": 2.3522,
      "radiusKm": 25
    },
    {
      "name": "Cologne depot",
      "latitude": 50.9375,
      "longitude": 6.9603,
      "radiusKm": 25
    },
    {
      "name": "Sacramento plant",
      "latitude": 38.5816,
      "longitude": -121.4944,
      "radiusKm": 25
    }
  ],
  "maxItems": 100
}' |
apify call maliksaid/flood-warnings-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,maliksaid/flood-warnings-monitor"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/dDMlCh72a1IwCZ4b7/builds/avPiynn6iMJkJ2ddb/openapi.json