Donaupegel-API und offene Daten

Der Link in der Bestätigungs-E-Mail einer Warnung oder eines Tagesberichts, verschickt, solange das Konto seine Adresse noch nicht nachgewiesen hat. **Er schaltet nichts ein** ( Link-Scanner von Firmen öffnen E-Mails von selbst ): Der Browser wird auf die öffentliche Seite `/{lang}/alerts/confirm` geführt, mit einer einzigen Schaltfläche, die `POST /alerts/confirm` ausführt. Mit `format=json` ( oder `Accept: application/json` ) wird nur der Zustand zurückgegeben: 200 mit `status` `pending` / `active`, 404 für ein ungültiges Token.

curl -sS "https://danubealert.arcm.ro/api/v1/alerts/confirm?t=t"

const r = await fetch('https://danubealert.arcm.ro/api/v1/alerts/confirm?t=t')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/alerts/confirm?t=t", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Der einzige Schritt, der das Abonnement einschaltet ( `activ = true` ): die Schaltfläche der Bestätigungsseite oder ein Client, mit dem Token in der Query ( `t` ) oder im Rumpf ( `{ "t": "…" }` ). Nur ein noch wartendes Abonnement startet; eines, das inzwischen im Konto ausgeschaltet wurde, bleibt aus. Hier wird auch die Adresse des Kontos nachgewiesen. Der Browser wird auf die öffentliche Seite des Abonnements geführt ( „eingeschaltet“ ), ein Client erhält JSON ( `kind`: `alert` / `report` ).

Der Regen der letzten abgeschlossenen 24 h und 72 h, je Teileinzugsgebiet: der Berechnungspunkt ist eine Messstelle am Oberlauf, und die Zeile ist mit der Messstelle flussab verknüpft — das Vorläufersignal eines Wasserstandsanstiegs dort. Die Stundenreihe stammt aus einer offenen Wetterquelle ( CC BY 4.0, siehe `_attribution` ); `window_end` ist der Zeitpunkt, bis zu dem die Stunden summiert sind ( exklusiv ), und `hours_24h` / `hours_72h` sagen, wie viele Stunden mit Wert in jedes Fenster eingegangen sind. Ein Teileinzugsgebiet, dessen Lauf fehlgeschlagen ist, behält sein letztes `window_end`.

curl -sS "https://danubealert.arcm.ro/api/v1/basin-precipitation"

const r = await fetch('https://danubealert.arcm.ro/api/v1/basin-precipitation')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/basin-precipitation", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Dieselben Zeilen wie `/stations`, nach Land gefiltert; jede hat den Block `quality` ( Referenzquelle, letzter Messwert, G3-Zustand und Pegelnullpunkt ).

curl -sS "https://danubealert.arcm.ro/api/v1/countries/HU/stations"

const r = await fetch('https://danubealert.arcm.ro/api/v1/countries/HU/stations')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/countries/HU/stations", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Der Tagesbericht als ein einziges Objekt, für die Seite `/{lang}/today` ( UX-9 ). `basin` ist genau das Aggregat „Die Lage heute“ ( die Summe und die Zeilen je Land ), `changes` ist der Block F4 ( die 24-h-Variation, die Q74-Welle, die D2-Abweichung ), `thresholds` listet die Messstellen mit frischem Messwert unter LDC / über HDC ( mit Schwelle, Wasserstand und Differenz ), und `forecast` liefert die **24–72 h**-Prognose aus G2 ( Quelle, Ausgabe, Horizont der Quelle, Min–Max-Band je Horizont und `orientativ` ), nur für Messstellen mit einer signifikanten Prognose: Sie erreicht eine Schwelle oder bewegt sich mindestens 25 cm gegenüber dem aktuellen Wasserstand. Die Liste ist begrenzt ( 12 je Einzugsgebiet, 3 je Land ), mit der Summe vor der Begrenzung; die Tage 4–5 ( +96 / +120 h ) sind nicht Teil des Berichts.

curl -sS "https://danubealert.arcm.ro/api/v1/report/today"

const r = await fetch('https://danubealert.arcm.ro/api/v1/report/today')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/report/today", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Die paginierte Liste der Messstellen, mit Wasserstand, Prognose und dem Block `quality` in jeder Zeile: Referenzquelle, Zeitpunkt des letzten Messwerts, G3-Zustand ( aktuell / „alter Messwert“ / keine Daten ) und Pegelnullpunkt ( national / anderer / absolut / unbekannt ).

curl -sS "https://danubealert.arcm.ro/api/v1/stations"

const r = await fetch('https://danubealert.arcm.ro/api/v1/stations')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/stations", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Die Messstellenseite: die LDC/HDC-Schwellen, die Koordinaten, die Aktualität der Referenzquelle ( Q88 ), die Abdeckung der Reihe über 365 Tage ( Q94 ), der Block `quality` — Referenzquelle, letzter Messwert, G3-Zustand und Pegelnullpunkt ( H4 ) —, der Block `anomaly` — die Abweichung des heutigen Wasserstands von der Klimatologie des Tages ( D1 ), unter 10 Referenzjahren nicht vorhanden — und, wenn die Messstelle eine Prognose hat, der Block `forecast` mit Quelle, `horizon_hours` ( wie weit die Prognose reicht ) und den Horizonten mit ihrem Min–Max-Band ( G2, UX-11 §8.1 S. 6 ).

curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest"

const r = await fetch('https://danubealert.arcm.ro/api/v1/stations/budapest')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/stations/budapest", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Die für die Messstelle dokumentierten großen Hochwasser und Dürren, die neuesten zuerst ( Jahr, dann der Scheiteltag ). Jede Zeile enthält Art, Jahr, den Scheiteltag, wenn die Quelle ihn veröffentlicht, den Wert am Pegel der Messstelle mit seiner Einheit, den Quellcode, die Institution und die öffentliche URL. `?tip=viitura|seceta` filtert die Art. Die Zeilen stammen aus der redaktionellen Sammlung `evenimente-istorice`, in der Quelle und Beleg jeder Zeile Pflicht sind. `_attribution.data_updated_at` ist das neueste Prüfdatum der zurückgegebenen Zeilen.

curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/events"

const r = await fetch('https://danubealert.arcm.ro/api/v1/stations/budapest/events')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/stations/budapest/events", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/neighbors"

const r = await fetch('https://danubealert.arcm.ro/api/v1/stations/budapest/neighbors')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/stations/budapest/neighbors", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Dieselben Daten wie `/v1/stations`, mit dem v2-Listenvertrag: Keyset-Cursor-Paginierung, `fields=` und `format=json|csv|geojson`. Die Antwort ist cachefähig (`ETag`, `Last-Modified`, `Cache-Control`), und `If-None-Match` liefert `304`.

curl -sS "https://danubealert.arcm.ro/api/v2/stations"

const r = await fetch('https://danubealert.arcm.ro/api/v2/stations')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v2/stations", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Donauabschnitte von der Quelle bis zur Mündung ( je Land, mit Kilometerbereich und den Pegeln des Abschnitts ) und die Flüsse jedes Landes, nach Pegelanzahl geordnet. Mit `q` werden Pegel und Flüsse nach Namen gesucht; Diakritika und Kyrillisch werden toleriert; `limit` ( 1–50 ) begrenzt die Listen. Gecacht wie der übrige Katalog.

curl -sS "https://danubealert.arcm.ro/api/v1/wizard"

const r = await fetch('https://danubealert.arcm.ro/api/v1/wizard')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/wizard", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Backtest der Zeilen aus `forecasts` gegen die tatsächlichen Messwerte aus `readings`, je Quelle × Horizont ( +24 / +48 / +72 h ): mittlerer absoluter Fehler ( `mae_cm` ), vorzeichenbehafteter Bias ( `bias_cm`, positiv = die Prognose lag zu hoch ) und der Anteil der Messwerte im veröffentlichten Min–Max-Band ( `within_band_pct`, nur bei Stichproben mit Band ). Die Liste enthält alle Quellen mit Prognose im Fenster, auch jene noch ohne Paare ( `samples: 0`, `null`-Mittelwerte ). Standardfenster: 90 Tage nach dem Zielzeitpunkt; jede Prognose wird mit dem nächstgelegenen Messwert innerhalb ±6 h verglichen, wobei die Reihe des Herausgebers bevorzugt wird, sonst die Referenzquelle der Messstelle. Ohne Messwert im Fenster geht die Prognose nicht in die Stichprobe ein. Ohne `station` gilt das Aggregat für das ganze Einzugsgebiet; mit `station` nur für die angefragte Messstelle — dieselben Zahlen wie `/stations/{slug}/forecast-accuracy`. Schwerer Endpunkt: 10 Anfragen/Min.

curl -sS "https://danubealert.arcm.ro/api/v1/forecast/accuracy"

const r = await fetch('https://danubealert.arcm.ro/api/v1/forecast/accuracy')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/forecast/accuracy", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Schwere Route: 10 Anfragen/Minute, auch mit Schlüssel.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

curl -sS "https://danubealert.arcm.ro/api/v1/measurements?station=budapest"

const r = await fetch('https://danubealert.arcm.ro/api/v1/measurements?station=budapest')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/measurements?station=budapest", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Dieselben Regeln wie bei den Beobachtungen einer Messstelle; `interval` ist standardmäßig `daily` und das Ratenlimit ist das schwere ( 10/min ).

curl -sS "https://danubealert.arcm.ro/api/v1/observations?stations=budapest%2Cmohacs"

const r = await fetch('https://danubealert.arcm.ro/api/v1/observations?stations=budapest%2Cmohacs')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/observations?stations=budapest%2Cmohacs", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Schwere Route: 10 Anfragen/Minute, auch mit Schlüssel.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Die Referenzreihe der Messstelle für jeden Kalendertag ( `MM-DD` ): aus der gesamten Geschichte des Tages-Rollups, wie viele Jahre beigetragen haben, Mittelwert, Median, die Perzentile 10 / 25 / 75 / 90, Minimum, Maximum und Standardabweichung. Der Wert eines Tages ist der erste Messwert des lokalen Tages aus der tatsächlichen Referenzquelle der Messstelle. Die Grundlage für „heute liegt der Pegel X cm unter dem Tagesnormal“; die Abweichung selbst steht im Block `anomaly` der Messstellenseite und in `GET /summary/today`.

curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/climatology"

const r = await fetch('https://danubealert.arcm.ro/api/v1/stations/budapest/climatology')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/stations/budapest/climatology", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Schwere Route: 10 Anfragen/Minute, auch mit Schlüssel.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Die Abflussreihe aus der Tabelle `masuratori` ( die Messgröße `debit` ), geschrieben von den nationalen hydrologischen Diensten. Eine Antwort enthält eine einzige Quelle ( `source` ): ohne `source=` wird die Quelle der neuesten Abflussmessung genommen, damit Reihen verschiedener Quellen nicht vermischt werden. `interval=hourly|daily` aggregiert über den Mittelwert. Schwerer Endpunkt: 10 Anfragen/Minute anonym.

curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/discharge"

const r = await fetch('https://danubealert.arcm.ro/api/v1/stations/budapest/discharge')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/stations/budapest/discharge", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Die letzte Ausgabe aus einer einzigen Quelle ( `source` ); Reihen verschiedener Quellen werden nicht vermischt. `horizon_hours` sagt, wie weit die Prognose der Ausgabe reicht ( je nach Quelle von +48 h bis +120 h ), und jeder Horizont hat das von der Quelle veröffentlichte Min–Max-Band ( `level_min_cm` / `level_max_cm`, `null` wo sie keines angibt ). Die Tage 4–5 ( +96 / +120 h ) tragen `orientativ: true`: sie erscheinen in den Daten, lösen aber keine Warnungen aus — die Engine nutzt nur 24–72 h.

curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/forecast"

const r = await fetch('https://danubealert.arcm.ro/api/v1/stations/budapest/forecast')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/stations/budapest/forecast", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Backtest der für die Messstelle im Pfad ausgegebenen Prognosen gegen ihre tatsächlichen Messwerte, je Quelle × Horizont ( +24 / +48 / +72 h ): mittlerer absoluter Fehler ( `mae_cm` ), vorzeichenbehafteter Bias ( `bias_cm`, positiv = die Prognose lag zu hoch ) und der Anteil der Messwerte im veröffentlichten Min–Max-Band ( `within_band_pct` ). Die Liste enthält **alle Quellen mit Prognose** für die Messstelle im Fenster; eine Quelle ohne ein einziges Prognose-Messwert-Paar erscheint trotzdem, mit `samples: 0` und `null`-Mittelwerten. Standardfenster: 90 Tage nach dem Zielzeitpunkt; der Messwert wird bei ±6 h genommen, wobei die Reihe des Herausgebers bevorzugt wird, sonst die Referenzquelle der Messstelle. Dieselben Zahlen wie `/forecast/accuracy?station=<slug>`. Schwerer Endpunkt: 10 Anfragen/Min.

curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/forecast-accuracy"

const r = await fetch('https://danubealert.arcm.ro/api/v1/stations/budapest/forecast-accuracy')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/stations/budapest/forecast-accuracy", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Schwere Route: 10 Anfragen/Minute, auch mit Schlüssel.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Die in den nationalen Berichten veröffentlichten Winterphänomene, je Messstelle und Tag vereinheitlicht. Die heutige Quelle ist ein täglicher nationaler Bericht: die Spalte `L` ( Index 0–8 ) wird zu `code`, und `phenomena` enthält die kanonischen englischen Codes ( `ice_floe`, `ice_bridge`, `shore_ice`… ). Ein Tag mit Index 0 ist eine echte Beobachtung ( `ice: false`, `code: 0`, `phenomena: []` ), keine fehlenden Daten. RO / BG / RS / HU veröffentlichen das Phänomen im Tagesbericht nicht je Messstelle ( siehe Beschreibung der Quellen ), daher erscheinen sie hier nicht.

curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/ice"

const r = await fetch('https://danubealert.arcm.ro/api/v1/stations/budapest/ice')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/stations/budapest/ice", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Ein schwerer Endpunkt für lange anonyme Historie: 10 Anfragen/Minute ( §3 ). Standardmäßig ist die Reihe die **Referenzquelle** der Messstelle ( die nationale Quelle; `source` im Rumpf ). Die Historie ist geschichtet: `source=` fordert die Reihe einer bestimmten Quelle, und `include_legacy=true` fügt den Block `legacy` mit der Legacy-Reihe hinzu ( ein anderer Pegel: `level_cm` wie die Quelle ihn veröffentlicht, `level_cm_aligned` auf den Nullpunkt des nationalen Pegels gebracht, wenn der Nullpunkt bekannt ist ). Die Reihen werden in `data` nie vermischt.

curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/observations"

const r = await fetch('https://danubealert.arcm.ro/api/v1/stations/budapest/observations')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/stations/budapest/observations", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Schwere Route: 10 Anfragen/Minute, auch mit Schlüssel.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Der Wasserstand des letzten Tages ( erster Messwert des lokalen Tages, Referenzquelle ) im Vergleich zum selben Kalendertag der letzten 30 Jahre. `percentile` reicht von 0 bis 100, `category` ist eines von very_low / low / normal / high / very_high; unter 10 Referenzjahren ist `percentile` null. Eine einzige Abfrage über das Jahrfenster, nicht eine pro Tag.

curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/percentile"

const r = await fetch('https://danubealert.arcm.ro/api/v1/stations/budapest/percentile')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/stations/budapest/percentile", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Schwere Route: 10 Anfragen/Minute, auch mit Schlüssel.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/records"

const r = await fetch('https://danubealert.arcm.ro/api/v1/stations/budapest/records')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/stations/budapest/records", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Schwere Route: 10 Anfragen/Minute, auch mit Schlüssel.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/same-day"

const r = await fetch('https://danubealert.arcm.ro/api/v1/stations/budapest/same-day')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/stations/budapest/same-day", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Schwere Route: 10 Anfragen/Minute, auch mit Schlüssel.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Die für die Messstelle veröffentlichten Winterbeobachtungen, die neuesten zuerst: der Text des Phänomens und/oder die Eisdicke in cm. Ohne Beobachtungen ist die Liste leer.

curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/winter"

const r = await fetch('https://danubealert.arcm.ro/api/v1/stations/budapest/winter')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/stations/budapest/winter", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Hydrologische Dürre an der Donau, nach Abschnitt ( die Länder des Flusses, von flussauf nach flussab ): für das gewählte Jahr der längste ununterbrochene Zeitraum unter LDC einer Messstelle im Abschnitt, die Rekordmessstelle, wie viele Messstellen Niedrigwasser hatten, die Messstellen-Tage unter LDC, der Verlauf des Abschnitts und der Vergleich mit den Referenzjahren 2003, 2015, 2018 und 2022. Dieselben Regeln wie die Registerkarte „Niederwasser“ auf `/{lang}/statistics`: Schwellen werden am Referenzmesswert aus dem Rollup beurteilt, und ein fehlender Tag bricht den Zeitraum.

curl -sS "https://danubealert.arcm.ro/api/v1/summary/low-water"

const r = await fetch('https://danubealert.arcm.ro/api/v1/summary/low-water')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/summary/low-water", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Das Tagesaggregat je Land: wie viele Messstellen unter LDC und über HDC liegen ( mit dem Anteil der Messstellen mit Schwellen ), wie viele in den letzten 48 h keinen Messwert haben, der 24-h-Trend ( steigend / fallend / stabil ) und die Prognose für die nächsten 24–72 h. D2 ergänzt die Abweichung vom Tagesnormal ( die Klimatologie D1 ): wie viele Messstellen über p75, unter p25 oder im normalen Bereich liegen, und die Rangliste der größten standardisierten Abweichungen. F4 ergänzt „was sich heute ändert“: die ersten signifikanten Änderungen aus der 24-h-Variation, aus der Q74-Welle ( Laufzeit flussauf → flussab ) und aus der D2-Abweichung, je Einzugsgebiet ( `changes` ) und je Land ( `changes_by_country` ). Dieselben Regeln wie die Seite `/{lang}/today`: Schwellen werden am frischen Referenzmesswert beurteilt, und die Prognose stammt aus einer einzigen Ausgabe.

curl -sS "https://danubealert.arcm.ro/api/v1/summary/today"

const r = await fetch('https://danubealert.arcm.ro/api/v1/summary/today')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/summary/today", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

curl -sS "https://danubealert.arcm.ro/api/v1/countries"

const r = await fetch('https://danubealert.arcm.ro/api/v1/countries')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/countries", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

curl -sS "https://danubealert.arcm.ro/api/v1/rivers"

const r = await fetch('https://danubealert.arcm.ro/api/v1/rivers')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/rivers", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

curl -sS "https://danubealert.arcm.ro/api/v1/rivers/sava"

const r = await fetch('https://danubealert.arcm.ro/api/v1/rivers/sava')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/rivers/sava", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Die Länder des Einzugsgebietsregisters, mit Namen in den Sprachen des Produkts; der Cursor ist der ISO-Code.

curl -sS "https://danubealert.arcm.ro/api/v2/countries"

const r = await fetch('https://danubealert.arcm.ro/api/v2/countries')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v2/countries", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Die Flüsse im Messstellenregister, mit der Zahl der Messstellen je Land. Der Cursor ist der normalisierte Flusscode; `fields=` und `format=json|csv|geojson` gelten auf allen v2-Listen gleich.

curl -sS "https://danubealert.arcm.ro/api/v2/rivers"

const r = await fetch('https://danubealert.arcm.ro/api/v2/rivers')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v2/rivers", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

curl -sS "https://danubealert.arcm.ro/api/v1/export/country/HU"

const r = await fetch('https://danubealert.arcm.ro/api/v1/export/country/HU')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/export/country/HU", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Schwere Route: 10 Anfragen/Minute, auch mit Schlüssel.

Auch der Export enthält `_attribution`, mit der Lizenz in `_attribution.license` (CC BY 4.0); zeige `_attribution.source`, `_attribution.url` und die Lizenz neben der Datei.

Die Datei des Vortags für ein Land des Einzugsgebiets, mit Lizenz CC BY 4.0 und Quellenangabe. Die CSV legt sie in die Kopfzeilen `Link`, `X-Attribution*` und `X-License*`, die JSON in `_attribution` ( einschließlich `license` ). Die Antwort ist cachefähig: `ETag`, `Last-Modified`, `Cache-Control`, und `If-None-Match` liefert 304 mit denselben Kopfzeilen.

curl -sS "https://danubealert.arcm.ro/api/v1/export/daily?country=HU"

const r = await fetch('https://danubealert.arcm.ro/api/v1/export/daily?country=HU')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/export/daily?country=HU", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Schwere Route: 10 Anfragen/Minute, auch mit Schlüssel.

Auch der Export enthält `_attribution`, mit der Lizenz in `_attribution.license` (CC BY 4.0); zeige `_attribution.source`, `_attribution.url` und die Lizenz neben der Datei.

Eine Seite des Tages-Rollups (`readings_daily`) über den Zeitraum `from`–`to`, nur aus Quellen mit ausdrücklicher Weiterverbreitungslizenz ( das Q90-Lizenzregister ). Jede Zeile enthält die Spalte `license` der Quelle; die vollständige Quellenangabe und die URL der Bedingungen stehen im Manifest `/export/range/licenses` und in den Kopfzeilen `X-License` / `X-Attribution` / `Link`. Die Paginierung erfolgt mit `cursor` ( `X-Next-Cursor`, `Link: rel="next"` ), über einen Fingerabdruck an die Filter gebunden: zwei aufeinanderfolgende Seiten wiederholen und überspringen keine Zeilen. Ohne Schlüssel: höchstens 366 Tage und 500 Zeilen pro Seite; mit Schlüssel (`Authorization: Bearer`): 20 Jahre und 5 000 Zeilen pro Seite. Der Export ist ein schwerer Endpunkt ( 10 Anfragen/Minute ).

curl -sS "https://danubealert.arcm.ro/api/v1/export/range?from=2026-01-01&to=2026-10-23"

const r = await fetch('https://danubealert.arcm.ro/api/v1/export/range?from=2026-01-01&to=2026-10-23')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/export/range?from=2026-01-01&to=2026-10-23", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Schwere Route: 10 Anfragen/Minute, auch mit Schlüssel.

Auch der Export enthält `_attribution`, mit der Lizenz in `_attribution.license` (CC BY 4.0); zeige `_attribution.source`, `_attribution.url` und die Lizenz neben der Datei.

Das Manifest der Quellen, die in `GET /export/range` erscheinen können: nur jene mit ausdrücklicher Weiterverbreitungslizenz, jede mit Institution, Lizenz, URL der Bedingungen, Quellenangabe, der vorgenommenen Umwandlung ( Tagesaggregat ) und dem Prüfdatum. Eine abgelehnte oder unbekannte Quelle erscheint nicht im Manifest und wird nicht exportiert.

curl -sS "https://danubealert.arcm.ro/api/v1/export/range/licenses"

const r = await fetch('https://danubealert.arcm.ro/api/v1/export/range/licenses')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/export/range/licenses", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Auch der Export enthält `_attribution`, mit der Lizenz in `_attribution.license` (CC BY 4.0); zeige `_attribution.source`, `_attribution.url` und die Lizenz neben der Datei.

curl -sS "https://danubealert.arcm.ro/api/v1/export/river/sava"

const r = await fetch('https://danubealert.arcm.ro/api/v1/export/river/sava')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/export/river/sava", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Schwere Route: 10 Anfragen/Minute, auch mit Schlüssel.

Auch der Export enthält `_attribution`, mit der Lizenz in `_attribution.license` (CC BY 4.0); zeige `_attribution.source`, `_attribution.url` und die Lizenz neben der Datei.

curl -sS "https://danubealert.arcm.ro/api/v1/bulletins"

const r = await fetch('https://danubealert.arcm.ro/api/v1/bulletins')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/bulletins", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Nur die aktiven Zeilen; abgelaufene Einschränkungen ( ein vergangenes `data_end` ) werden nicht mehr zurückgegeben, und Einschränkungen stammen nur aus den aufbewahrten amtlichen Quellen. Die Antwort ist nach rkm sortiert.

curl -sS "https://danubealert.arcm.ro/api/v1/navigation"

const r = await fetch('https://danubealert.arcm.ro/api/v1/navigation')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/navigation", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Nur die aktiven Schwellen ( archivierte Werte bleiben mit `activ: false` in der Plattform und werden nicht veröffentlicht ). `station` ist der Slug der Messstelle; ein unbekannter Slug liefert 404.

curl -sS "https://danubealert.arcm.ro/api/v1/thresholds"

const r = await fetch('https://danubealert.arcm.ro/api/v1/thresholds')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/thresholds", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Die nationalen Berichte, die neuesten zuerst; `country` filtert, der Cursor ist die Berichts-ID.

curl -sS "https://danubealert.arcm.ro/api/v2/bulletins"

const r = await fetch('https://danubealert.arcm.ro/api/v2/bulletins')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v2/bulletins", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Kritische Stellen und aktive Einschränkungen in einer einzigen Liste, jede Zeile mit `kind` (`punct_critic` oder `restrictie` ); der Cursor setzt sich aus `kind:id` zusammen. Geometrie gibt es bei Punkten.

curl -sS "https://danubealert.arcm.ro/api/v2/navigation"

const r = await fetch('https://danubealert.arcm.ro/api/v2/navigation')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v2/navigation", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Die aktiven Schwellen, mit `station` ( Slug ) als Filter; der Cursor ist die Schwellen-ID. Ein unbekannter Slug liefert 404, wie in v1.

curl -sS "https://danubealert.arcm.ro/api/v2/thresholds"

const r = await fetch('https://danubealert.arcm.ro/api/v2/thresholds')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v2/thresholds", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

curl -sS "https://danubealert.arcm.ro/api/v1/episodes"

const r = await fetch('https://danubealert.arcm.ro/api/v1/episodes')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/episodes", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

curl -sS "https://danubealert.arcm.ro/api/v1/episodes/1"

const r = await fetch('https://danubealert.arcm.ro/api/v1/episodes/1')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/episodes/1", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

curl -sS "https://danubealert.arcm.ro/api/v1/geojson/rivers"

const r = await fetch('https://danubealert.arcm.ro/api/v1/geojson/rivers')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/geojson/rivers", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

curl -sS "https://danubealert.arcm.ro/api/v1/geojson/stations"

const r = await fetch('https://danubealert.arcm.ro/api/v1/geojson/stations')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/geojson/stations", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Der öffentliche Bericht „Datentransparenz“: ein Monat je Quelle über die letzten 12 Kalendermonate, mit den gezählten Tagen (`days`, der laufende Monat nur bis gestern), den Tagen mit mindestens einem Messwert (`days_with_data`) und ihrem Prozentsatz. `last_7_days` liefert die Läufe und Fehlschläge der letzten 7 Tage aus dem Q62-Journal (`runs` / `failures`; `null` = kein Journal). Nur Zahlen: keine Fehlermeldungen, keine URLs, keine Messstellendetails. Ohne das Tages-Rollup ( Instanz ohne Ingest ) ist `sources` leer, nicht „0 %“.

curl -sS "https://danubealert.arcm.ro/api/v1/meta/availability"

const r = await fetch('https://danubealert.arcm.ro/api/v1/meta/availability')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/meta/availability", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

curl -sS "https://danubealert.arcm.ro/api/v1/meta/health"

const r = await fetch('https://danubealert.arcm.ro/api/v1/meta/health')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/meta/health", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Aggregat je Messstelle: die Zahl der verdächtigen Messwerte ( Abweichung über einer Schwelle vom Median der Nachbarn ±6 h ), der letzte Messwert und der Zustand der Quelle, die ihn geliefert hat ( `source_state`: `ok`, `eroare`, `stale` — „keine Messwerte im Termin“ ).

curl -sS "https://danubealert.arcm.ro/api/v1/meta/quality"

const r = await fetch('https://danubealert.arcm.ro/api/v1/meta/quality')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/meta/quality", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Eine Zeile je Crawl-Quelle: der letzte erfolgreiche Lauf, ihr Zustand, der SLA, **der letzte Schreibvorgang**, **die gelesenen Zeilen und die geschriebenen Messwerte der letzten 24 h**, **die Uptime über 7 und 30 Tage**, **die mittlere Verzögerung** der Daten ( das mittlere Alter des frischesten Messwerts über 7 Tage ) und **der letzte Fehler** ( auch nach der Rückkehr der Quelle aufbewahrt ). `stare` kann `cazuta` sein, wenn die Quelle seit mehr als 2 × ihrem Intervall nichts geschrieben hat, und `eroare` bedeutet, dass der letzte Lauf fehlgeschlagen ist **und** die Daten davor den SLA der Quelle verletzt haben; ein Netzausfall, solange die Daten noch im Termin sind, lässt `stare` unverändert ( der Fehler bleibt in `ultima_eroare` ). `uptime_7d` / `uptime_30d` sind Brüche 0–1; `null` = das Fenster ist nicht berechenbar oder `readings` ist gerade nicht verfügbar, nicht „perfekte Quelle“.

curl -sS "https://danubealert.arcm.ro/api/v1/meta/sources"

const r = await fetch('https://danubealert.arcm.ro/api/v1/meta/sources')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v1/meta/sources", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.

Der letzte Lauf und die Qualität über die Zeit je Quelle; der Cursor ist der Quellcode. Die Felder sind jene von `/v1/meta/sources`.

curl -sS "https://danubealert.arcm.ro/api/v2/meta/sources"

const r = await fetch('https://danubealert.arcm.ro/api/v2/meta/sources')
if (!r.ok) throw new Error(`HTTP ${r.status}`)
const body = await r.json()
console.log(body)
console.log(body._attribution.source, body._attribution.url)

import requests

r = requests.get("https://danubealert.arcm.ro/api/v2/meta/sources", timeout=30)
r.raise_for_status()
body = r.json()
print(body)
print(body["_attribution"]["source"], body["_attribution"]["url"])

Ratenlimit: Anonym: 60 Anfragen/Minute (gleitendes Fenster); mit `Authorization: Bearer <Schlüssel>`: 600/Minute.

Die Antwort enthält `_attribution`; zeige `_attribution.source` und `_attribution.url` neben den Daten.