# EU Weather Alert Monitor — KNMI + EU-METEOALARM (`codeclouds/eu-weather-alert-monitor`) Actor

Real-time weather alert aggregation for the EU from KNMI (Netherlands) and EU-METEOALARM (EU-wide Atom feeds, CC BY 4.0). Flat JSON output with region, severity, status, source attribution, and optional incremental change tracking.

- **URL**: https://apify.com/codeclouds/eu-weather-alert-monitor.md
- **Developed by:** [Dennis](https://apify.com/codeclouds) (community)
- **Categories:** Other, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 eu weather alert records

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

## EU Weather Alert Monitor

**Actor name:** `eu-weather-alert-monitor`\
**Category:** Weather\
**Language:** English (actor interface); output records contain region codes for EU countries.

***

### What it does

The **EU Weather Alert Monitor** aggregates active, official weather alerts for the European Union from two authoritative public sources:

- **KNMI Data Platform** (`waarschuwingen_nederland_48h`) — Netherlands national meteorological service, official open-data REST-JSON API.
- **EU-METEOALARM** (`feeds.meteoalarm.org`) — EU-wide early-warning dissemination system, Atom feeds per country under CC BY 4.0.

For each active alert, the actor produces a flat JSON record with a stable `alertId`, region, severity level, event description, status (`actual`), timestamps, source URL, and an optional raw-text excerpt for transparency. You can filter by source (`KNMI`, `EU-METEOALARM`), region code, severity, and enable incremental tracking (`trackChanges`) to detect new, updated, unchanged, or removed alerts compared to the previous run.

***

### Why this actor exists

LLMs and AI agents can describe weather conditions in general terms, but they cannot maintain a reliable, real-time, geographically filtered, version-tracked alert feed with official government classifications. General weather APIs provide temperature or precipitation forecasts — not the official KNMI codes (`geel` / `oranje` / `rood`) or METEOALARM country-level warnings. There are zero EU-specific actors on the Apify Store for structured weather-alert monitoring; the closest category is US-only NOAA/NWS actors.

This actor fills that gap: structured, programmatic access to EU government weather alerts, designed for monitoring pipelines, risk-analysis agents, notification systems, and research workflows that need authoritative classification rather than raw forecast numbers.

***

### Capabilities

- **Live aggregation** from KNMI (Netherlands) and EU-METEOALARM (EU-wide Atom feeds).
- **Flat JSON output** — one record per alert, easy to consume in downstream pipelines.
- **Region filtering** — filter by country/region code (e.g., `NL`, `DE`, `FR`, `BE`).
- **Severity filtering** — include only specific severity levels (e.g., `geel`, `oranje`, `rood`, `yellow`, `orange`, `red`).
- **Incremental mode** (`trackChanges`) — compares with the previous run snapshot (named KV store) and reports `new`, `updated`, `unchanged`, or `removed`.
- **Transparent attribution** — each record includes the official source URL and raw text for auditability.
- **Public-data safe** — no scraping of private or paywalled content; all sources are official open-government APIs and feeds.

***

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `sourceFilter` | array of strings | none | Filter by source: `KNMI`, `EU-METEOALARM`, `ECMWF`. |
| `regionFilter` | array of strings | `[]` | Region codes to include (e.g., `["NL", "DE"]`). |
| `severityFilter` | array of strings | `[]` | Severity levels to include. Empty = include all. |
| `maxResults` | integer | `50` | Maximum records to return (1–500). |
| `trackChanges` | boolean | `false` | Enable incremental comparison with previous run. |
| `includeDetailed` | boolean | `false` | v1.1+: include KNMI detailed XML. v1 returns summary only. |
| `knmiApiKey` | string | demo key (test only) | Your registered KNMI API key. Recommended for production. |

***

### Output format (JSON example)

```json
[
  {
    "alertId": "knmi-knmi_waarschuwingen_202302011329-xml",
    "source": "KNMI",
    "region": "NL",
    "event": "KNMI active warning",
    "severity": "unknown",
    "status": "actual",
    "startDate": "2026-09-21T13:26:00.000Z",
    "url": "https://dataplatform.knmi.nl/datasets/waarschuwingen_nederland_48h",
    "rawText": "KNMI dataset: knmi_waarschuwingen_202302011329.xml (2678627 bytes)",
    "changeType": "new"
  },
  {
    "alertId": "meteo-nl-Orange-warnin-MTMwMD",
    "source": "EU-METEOALARM",
    "region": "NL",
    "event": "Orange warning for thunderstorms",
    "severity": "orange",
    "status": "actual",
    "startDate": "2026-09-21T10:00:00Z",
    "url": "https://feeds.meteoalarm.org/feeds/meteoalarm-legacy-atom-netherlands",
    "rawText": "Details here",
    "changeType": "new"
  }
]
```

Each record is independent and non-nullable for core fields (`alertId`, `source`, `region`, `event`, `severity`, `status`, `startDate`, `url`). Optional fields (`endDate`, `rawText`, `changeType`) appear only when applicable.

***

### Use cases

#### 1. AI-agent risk assessment

> "Are there any active severe weather warnings in the Netherlands or Germany right now? Only return official government classifications."

#### 2. Monitoring pipeline

> "Run every 30 minutes, filter by `regionFilter: ["NL", "DE"]`, and send a Slack notification only when `changeType` is `new` or `updated` (use `trackChanges: true`)."

#### 3. EU-wide severe-weather dashboard

> "Aggregate all `orange` and `red` alerts across EU countries for a real-time risk dashboard."

#### 4. Research / data audit

> "Compare METEOALARM Atom feed output with KNMI `.txt` summary to verify consistency between EU and NL national sources."

***

### Pricing (PPE — Pay Per Event)

- `eu-weather-alert-record`: **$0.002** per alert record. Comparable to other official government-feed monitors in the portfolio.
- `eu-weather-alert-change`: **$0.003** per change-detected record (new/updated) when `trackChanges` is enabled. Higher value for incremental monitoring pipelines.

***

### When should an AI agent use this?

- When the user asks for **current official weather warnings** in a specific EU country or across the EU.
- When the user needs **structured, machine-readable alert data** (not a text summary or a weather forecast).
- When the user asks about **severe weather risk** based on government classifications (`geel`/`oranje`/`rood`, `yellow`/`orange`/`red`) rather than generic temperature or precipitation.
- When the user needs **incremental tracking** (`trackChanges`) to detect changes in alert status between runs.
- When the user wants to compare **KNMI national alerts** with **EU-METEOALARM EU-wide feeds**.
- When the user asks: **"Which EU countries have the most severe active weather warnings today?"** (use the summary aggregation).
- When the user needs a **structured feed** for an AI agent that can answer questions like: "Are there any active orange or red warnings in Germany?"; "What is the current KNMI warning level for the Netherlands?"; "Has a new weather alert appeared since the last run?"; "What is the source attribution and license for this alert?".

***

### FAQ

**Q: Do I need to register for an API key?**\
A: The actor includes a public KNMI demo key for testing. For production use (higher rate limits, dedicated quota, no shared-key `429` errors), request a free registered key at `developer.dataplatform.knmi.nl/get-started`. Pass it as the `knmiApiKey` input field.

**Q: Does the actor store historical data?**\
A: No archive is kept by default. With `trackChanges: true`, a snapshot of the previous run is stored in a named KV store (`eu-weather-alert-monitor-snapshot`) to detect changes. This snapshot is overwritten on each run.

**Q: What if the EU-METEOALARM feed changes format?**\
A: The Atom feed uses standard W3C Atom (`application/atom+xml`) with embedded CAP (`urn:oasis:names:tc:emergency:cap:1.2`). The parser uses regex-based extraction for robustness without external XML dependencies. If the feed structure changes materially, the parser may need an update.

**Q: Is there a legal restriction on using this data commercially?**\
A: No. KNMI open data and METEOALARM feeds are public-government data with standard attribution requirements. The actor includes proper source attribution and does not add proprietary interpretation. See the `legal` section in `STOREINFO.md`.

### Keywords

EU weather alerts, KNMI warnings, METEOALARM, severe weather monitor, weather alert aggregator, EU weather warnings, government weather data, public weather API, weather risk monitoring, AI agent weather tool, KNMI open data, EU-METEOALARM feeds, weather alert JSON, real-time weather warnings.

***

### Related Actors

- [`weather-alert-warning-monitor`](https://apify.com/codeclouds/weather-alert-warning-monitor) — US NOAA/NWS weather alerts. This EU actor complements it with European official sources.
- [`nl-netstoringen-monitor`](https://apify.com/codeclouds/nl-netstoringen-monitor) — Netherlands network outage monitor; similar incremental-change tracking pattern.

***

### Technical details

- **Framework:** Apify SDK v3 (`apify` package), TypeScript, Zod input validation.
- **Sources:** KNMI Open Data REST-JSON (`api.dataplatform.knmi.nl/open-data/v1`) and EU-METEOALARM Atom feeds (`feeds.meteoalarm.org`).
- **Output:** Default dataset (`dataset` storage) with flat JSON items; `output_schema.json` defines the schema; `dataset_schema.json` defines the Store table views.
- **Dependencies:** `apify`, `zod`. No external XML parser needed for v1.
- **Tests:** `tests/main.test.ts` covers input schema defaults, KNMI mapping, Atom parsing, and METEOALARM mapping using real fixture snippets from the live probes (2026-09-21).

***

### Legal & Attribution

- **KNMI:** Official open data (`developer.dataplatform.knmi.nl`). Attribution: KNMI Open Data (CC-BY-like). Actor passes `User-Agent` and uses user-provided `Authorization` header.
- **EU-METEOALARM:** Official EU early-warning system (`meteoalarm.eu`). Feeds published under **CC BY 4.0** (confirmed 2026-09-21: `https://feeds.meteoalarm.org/` links to `https://creativecommons.org/licenses/by/4.0/`). Data provided by EUMETNET members.
- **No personal data processed.** Pure meteorological warnings and public region codes only.

***

### Changelog

- **0.1.0 (2026-09-21):** Initial build — KNMI `.txt` summary + EU-METEOALARM Atom feeds, flat JSON output, region/severity filters, incremental `trackChanges`, 5 passing tests, live source probes verified.

***

*Built: 2026-09-21. Last verified: KNMI `200 OK` (10 files, `.txt` + `.xml`) and METEOALARM `200 OK` (`application/atom+xml`, 989 bytes, NL feed).*

# Actor input Schema

## `sourceFilter` (type: `array`):

Filter by data source: KNMI (Netherlands), EU-METEOALARM (EU-wide), or ECMWF.

## `regionFilter` (type: `array`):

Optional region codes (e.g., NL, DE, FR) to filter alerts.

## `severityFilter` (type: `array`):

Only include alerts with these severity levels (e.g., geel, oranje, rood, yellow, orange, red).

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

Maximum number of alert records to return (1-500).

## `trackChanges` (type: `boolean`):

Compare with previous run to report new/updated/removed alerts.

## `includeDetailed` (type: `boolean`):

For v1.1+: include KNMI detailed XML parsing. For v1, returns summary only.

## `knmiApiKey` (type: `string`):

Your registered KNMI Data Platform API key. The public demo key is used as fallback for testing only.

## Actor input object example

```json
{
  "regionFilter": [],
  "severityFilter": [],
  "maxResults": 50,
  "trackChanges": false,
  "includeDetailed": false
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("codeclouds/eu-weather-alert-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("codeclouds/eu-weather-alert-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 '{}' |
apify call codeclouds/eu-weather-alert-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,codeclouds/eu-weather-alert-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/GRZJ1tRMmtAq4QfVm/builds/dLP2K3h7x7NSy9n2L/openapi.json