Ugrás a tartalomra

API v1 · OpenAPI 3.1

Duna vízállás API és nyílt adatok

Ingyenes JSON API a Duna vízállásaihoz: állomások LDC/HDC küszöbökkel, napi adatsorok, GeoJSON és OpenAPI 3.1 szerződés, korlátokkal és kódpéldákkal.

Alap-URL
https://danubealert.arcm.ro/api/v1
Hitelesítés
Authorization: Bearer <key>

Ingyenes API-kulcs →OpenAPI 3.1 szerződés

Áttekintés

A nyilvános v1 API JSON formátumban adja a Duna-medence hidrológiai adatait: az állomásokat LDC/HDC küszöbökkel, a méréseket és előrejelzéseket, a hivatalos küszöbértékeket, a hajózás kritikus pontjait, a hidrológiai közleményeket, a GeoJSON-exportot és a források állapotát. A teljes szerződés: /api/v1/openapi.json (OpenAPI 3.1).

Csomagok és korlátok

Névtelenül (fejléc nélkül): percenként 60 kérés, CORS * a GET kéréseken. Integrátori kulccsal (Authorization: Bearer <kulcs>): percenként 600 kérés. A kulcsokat ingyen hozhatod létre a fiókodban. A hibás formátumú, ismeretlen vagy visszavont kulcs 401-et kap (WWW-Authenticate: Bearer error="invalid_token"), nem névtelen hozzáférést; a visszavont kulcs azonnal megszűnik működni.

  • Névtelen

    60kérés / perc

    Fejléc nélkül, CORS * GET-re — elég minden útvonal kipróbálásához.

  • Ingyenes API-kulcs

    600kérés / perc

    Authorization: Bearer <kulcs>, a fiókodban hozod létre, egyszer látható.

  • Nehéz útvonalak

    10kérés / perc

    Idősorok és exportok ( observations, export ), kulcsonként vagy IP-nként.

Példa

Egy állomás legutóbbi napi vízállása curl-lel és TypeScripttel.

curl
curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/observations"
TypeScript
// A mai vízállás Budapesten
const r = await fetch('https://danubealert.arcm.ro/api/v1/stations/budapest/observations?interval=daily&from=2026-10-01', {
  headers: { Authorization: `Bearer ${process.env.DANUBEALERT_KEY}` },
})
const { data } = await r.json()
console.log(data.at(-1)) // { observed_at: "2026-10-21T00:00:00Z", level_cm: 468 }

Végpontok

A nyilvános API v1 összes útvonala, csak olvasás ( GET ), paraméterekkel és futtatható kéréssel.

Példák útvonalanként

Minden útvonalnál ott van a futtatható curl-, JavaScript- és Python-kérés, a kéréskorlátja és a megjelenítendő `_attribution` blokk.

`_attribution` blokk
{
  "source": "National hydrological services of the Danube basin (see /v1/meta/sources)",
  "url": "https://danubealert.com/en/about",
  "data_updated_at": "2026-10-21T00:00:00Z"
}
_attribution · /export/daily
{
  "source": "National hydrological services of the Danube basin (see /v1/meta/sources)",
  "url": "https://danubealert.com/en/about",
  "license": {
    "id": "CC-BY-4.0",
    "name": "Creative Commons Attribution 4.0 International",
    "url": "https://creativecommons.org/licenses/by/4.0/"
  },
  "data_updated_at": "2026-10-21T00:00:00Z"
}

Állomások

  • GET/api/v1/alerts/confirmA riasztás vagy a napi jelentés e-mailben küldött megerősítő linkje: nem kapcsol be semmit, a megerősítő oldalt nyitja meg

    A link egy riasztás vagy napi jelentés megerősítő e-mailjében, amelyet akkor küldünk, ha a fiók még nem igazolta a címét. **Nem kapcsol be semmit** ( a cégek linkszkennerei maguktól megnyitják az e-maileket ): a böngésző a nyilvános `/{lang}/alerts/confirm` oldalra kerül, egyetlen gombbal, amely a `POST /alerts/confirm` kérést küldi. `format=json` esetén ( vagy `Accept: application/json` fejléccel ) csak az állapotot adja vissza: 200 a `status` `pending` / `active` értékével, 404 érvénytelen tokenre.

    Paraméterek

    • t*query
    • formatquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/alerts/confirm?t=t"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • POST/api/v1/alerts/confirmA riasztás vagy a napi jelentés bekapcsolása a megerősítő oldalról ( csak ez a lépés aktiválja )

    Az egyetlen lépés, amely bekapcsolja az előfizetést ( `activ = true` ): a megerősítő oldal gombja vagy egy kliens, a tokennel a lekérdezésben ( `t` ) vagy a törzsben ( `{ "t": "…" }` ). Csak egy még várakozó előfizetés indul; egy közben a fiókból kikapcsolt kikapcsolva marad. Itt igazolódik a fiók címe is. A böngésző az előfizetés nyilvános oldalára kerül ( „bekapcsolva” ), egy kliens JSON-t kap ( `kind`: `alert` / `report` ).

    Paraméterek

    • tquery
  • GET/api/v1/basin-precipitationÖsszegzett 24 / 72 órás csapadék részvízgyűjtőnként, az alvízi állomáshoz kötve

    Az utolsó lezárt 24 és 72 óra összesített esője, részvízgyűjtőnként: a számítási pont egy állomás a felső szakaszon, a sor pedig az alvízi állomáshoz kapcsolódik — a vízállás-emelkedés előjele ott. Az órás sor egy nyílt időjárási forrásból jön ( CC BY 4.0, lásd `_attribution` ); a `window_end` az az időpont, ameddig az órák összegződnek ( kizárólagos ), a `hours_24h` / `hours_72h` pedig megmondja, hány értékes óra került az egyes ablakokba. Egy részvízgyűjtő, amelynek futása meghiúsult, megtartja az utolsó `window_end` értéket.

    Paraméterek

    • stationquery
    • riverquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/basin-precipitation"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/countries/{code}/stationsEgy ország állomásai

    Ugyanazok a sorok, mint a `/stations` esetében, országra szűrve; mindegyikben ott a `quality` blokk ( referenciaforrás, utolsó mérés, G3 állapot és mérce-nullpont ).

    Paraméterek

    • code*path
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/countries/HU/stations"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/report/todayA nap egy objektumban: a vízgyűjtő állapota, mi változik ma, küszöb fölötti / alatti állomások, 24–72 órás előrejelzés

    A nap jelentése egyetlen objektumban, a `/{lang}/today` oldalhoz ( UX-9 ). A `basin` pontosan a „Mai helyzet” összesítés ( az összeg és az országonkénti sorok ), a `changes` az F4 blokk ( a 24 órás ingadozás, a Q74 hullám, a D2 eltérés ), a `thresholds` felsorolja a friss méréssel LDC alatt / HDC felett lévő állomásokat ( a küszöbbel, a vízállással és a különbséggel ), a `forecast` pedig a **24–72 órás** előrejelzést adja a G2-ből ( forrás, kiadás, a forrás horizontja, a horizontonkénti min–max sáv és az `orientativ` ), csak a jelentős előrejelzéssel rendelkező állomásokra: eléri a küszöböt, vagy legalább 25 cm-t mozdul a mostani vízálláshoz képest. A lista korlátozott ( 12 a vízgyűjtőn, 3 országonként ), a korlát előtti összeggel; a 4–5. nap ( +96 / +120 h ) nem része a jelentésnek.

    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/report/today"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/stationsAz állomások listája

    Az állomások lapozott listája, soronként a vízállással, az előrejelzéssel és a `quality` blokkal: referenciaforrás, az utolsó mérés ideje, a G3 állapot ( friss / „régi mérés” / nincs adat ) és a mérce nullpontja ( nemzeti / más / abszolút / ismeretlen ).

    Paraméterek

    • countryquery
    • riverquery
    • qquery
    • limitquery
    • next_cursorquery
    • sortquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/stations"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/stations/{slug}Egy állomás, LDC/HDC küszöbei és a napi eltérés a klimatológiától

    Az állomás adatlapja: az LDC/HDC küszöbök, a koordináták, a referenciaforrás frissessége ( Q88 ), a sor 365 napos lefedettsége ( Q94 ), a `quality` blokk — referenciaforrás, utolsó mérés, G3 állapot és mérce-nullpont ( H4 ) —, az `anomaly` blokk — a mai vízállás eltérése a nap klimatológiájától ( D1 ), 10 referenciaév alatt hiányzik — és, ha az állomásnak van előrejelzése, a `forecast` blokk a forrással, a `horizon_hours` mezővel ( milyen messzire szól az előrejelzés ) és a horizontokkal, a min–max sávjukkal ( G2, UX-11 §8.1 6. o. ).

    Paraméterek

    • slug*path
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/stations/{slug}/eventsEgy állomás történelmi árvizei és aszályai

    Az állomáshoz dokumentált nagy árvizek és aszályok, a legújabbak elöl ( az év, majd a csúcs napja ). Minden sorban ott a típus, az év, a csúcs napja, ha a forrás közzéteszi, az állomás mércéjén mért érték a mértékegységével, a forráskód, az intézmény és a nyilvános URL. A `?tip=viitura|seceta` szűri a típust. A sorok az `evenimente-istorice` szerkesztői gyűjteményből jönnek, ahol minden sor forrása és bizonyítéka kötelező. Az `_attribution.data_updated_at` a visszaadott sorok legújabb ellenőrzési dátuma.

    Paraméterek

    • slug*path
    • tipquery
    • limitquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/events"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/stations/{slug}/neighborsFelvízi / alvízi szomszédok és torkolatok

    Paraméterek

    • slug*path
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/neighbors"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v2/stationsÁllomáslista ( v2, kurzor + mezők + formátum )

    Ugyanazok az adatok, mint a `/v1/stations` esetében, a v2 listaszerződéssel: keyset kurzoros lapozás, `fields=` és `format=json|csv|geojson`. A válasz gyorsítótárazható (`ETag`, `Last-Modified`, `Cache-Control`), az `If-None-Match` pedig `304`-et ad.

    Paraméterek

    • countryquery
    • riverquery
    • qquery
    • limitquery
    • next_cursorquery
    • fieldsquery
    • formatquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v2/stations"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/wizardAz alerta-varázsló adatai: szakaszok, országok, folyók és keresés

    A Duna szakaszai a forrástól a torkolatig ( országonként, a kilométertartománnyal és a szakasz állomásaival ), valamint minden ország folyói, állomásszám szerint rendezve. A `q` állomás- és folyónév keresés; az ékezetek és a cirill betűk is elfogadottak; a `limit` ( 1–50 ) korlátozza a listákat. A többi katalógushoz hasonlóan gyorsítótárazva.

    Paraméterek

    • qquery
    • limitquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/wizard"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

Mérések és előrejelzések

  • GET/api/v1/forecast/accuracyA hivatalos előrejelzések pontossága a mért értékekhez képest, forrásonként és időtávonként ( +24 / +48 / +72 óra )10/min

    A `forecasts` sorainak backtestje a `readings` tényleges méréseihez képest, forrás × horizont bontásban ( +24 / +48 / +72 h ): átlagos abszolút hiba ( `mae_cm` ), előjeles bias ( `bias_cm`, pozitív = az előrejelzés túl magas volt ) és a közzétett min–max sávon belüli mérések aránya ( `within_band_pct`, csak a sávval rendelkező mintákon ). A listában minden előrejelzéssel rendelkező forrás szerepel az ablakban, azok is, amelyeknek még nincs párjuk ( `samples: 0`, `null` átlagok ). Az alapértelmezett ablak: 90 nap a célidőpont után; minden előrejelzést a ±6 órán belüli legközelebbi méréshez hasonlít, előnyben a kibocsátó sorát, különben az állomás referenciaforrását. Ha az ablakban nincs mérés, az előrejelzés nem kerül a mintába. `station` nélkül az összesítés az egész vízgyűjtőre szól; `station`-nel csak a kért állomásra — ugyanazok a számok, mint a `/stations/{slug}/forecast-accuracy` válaszában. Nehéz végpont: 10 kérés/perc.

    Paraméterek

    • stationquery
    • daysquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/forecast/accuracy"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Nehéz útvonal: 10 kérés/perc, kulccsal is.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/measurementsVízhőmérséklet, vízhozam, léghőmérséklet

    Paraméterek

    • station*query
    • measurequery
    • fromquery
    • toquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/measurements?station=budapest"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/observationsLegfeljebb 6 állomás összevetése egyetlen válaszban10/min

    Ugyanazok a szabályok, mint egy állomás méréseinél; az `interval` alapértéke `daily`, a kéréskorlát pedig a nehéz ( 10/perc ).

    Paraméterek

    • stations*query
    • fromquery
    • toquery
    • intervalquery
    • riverquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/observations?stations=budapest%2Cmohacs"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Nehéz útvonal: 10 kérés/perc, kulccsal is.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/stations/{slug}/climatologyAz év napjaira vetített klimatológia a teljes idősorból: átlag, medián és percentilisek10/min

    Az állomás referenciasora minden naptári napra ( `MM-DD` ): a napi összesítés teljes történetéből, hány év járult hozzá, az átlag, a medián, a 10 / 25 / 75 / 90 percentilis, a minimum, a maximum és a szórás. Egy nap értéke a helyi nap első mérése az állomás tényleges referenciaforrásából. Ez az alapja annak, hogy „ma X cm-rel a nap szokásos szintje alatt van”; maga az eltérés az állomás oldalának `anomaly` blokkjában és a `GET /summary/today` válaszában van.

    Paraméterek

    • slug*path
    • dayquery
    • limitquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/climatology"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Nehéz útvonal: 10 kérés/perc, kulccsal is.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/stations/{slug}/dischargeVízhozam-idősor ( m³/s )

    A vízhozam-sor a `masuratori` táblából ( a `debit` mérési mennyiség ), amelyet a nemzeti hidrológiai szolgálatok írnak. Egy válasz egyetlen forrást tartalmaz ( `source` ): `source=` nélkül a legújabb vízhozammérés forrása kerül bele, hogy a különböző források sorai ne keveredjenek. Az `interval=hourly|daily` átlagolással összesít. Nehéz végpont: névtelenül 10 kérés/perc.

    Paraméterek

    • slug*path
    • sourcequery
    • fromquery
    • toquery
    • intervalquery
    • formatquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/discharge"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/stations/{slug}/forecastAz állomás előrejelzése ( ahol van )

    A legutóbbi kiadás egyetlen forrásból ( `source` ); a különböző források sorai nem keverednek. A `horizon_hours` megmondja, milyen messzire szól a kiadás előrejelzése ( forrástól függően +48 órától +120 óráig ), és minden horizonton ott a forrás által közzétett min–max sáv ( `level_min_cm` / `level_max_cm`, `null` ahol nem ad ilyet ). A 4–5. nap ( +96 / +120 h ) `orientativ: true` jelölést kap: megjelenik az adatokban, de nem indít riasztást — a motor csak 24–72 h-t használ.

    Paraméterek

    • slug*path
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/forecast"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/stations/{slug}/forecast-accuracyEgy állomás előrejelzésének pontossága forrásonként és időtávonként: mennyire jó itt az előrejelzés10/min

    Az útvonalon megadott állomásra kiadott előrejelzések backtestje a tényleges méréseihez képest, forrás × horizont bontásban ( +24 / +48 / +72 h ): átlagos abszolút hiba ( `mae_cm` ), előjeles bias ( `bias_cm`, pozitív = az előrejelzés túl magas volt ) és a közzétett min–max sávon belüli mérések aránya ( `within_band_pct` ). A listában **minden előrejelzéssel rendelkező forrás** szerepel az ablakban; egy forrás, amelynek még nincs előrejelzés–mérés párja, `samples: 0` értékkel és `null` átlagokkal jelenik meg. Az alapértelmezett ablak: 90 nap a célidőpont után; a mérést ±6 órán belül veszi, előnyben a kibocsátó sorát, különben az állomás referenciaforrását. Ugyanazok a számok, mint a `/forecast/accuracy?station=<slug>` válaszában. Nehéz végpont: 10 kérés/perc.

    Paraméterek

    • slug*path
    • daysquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/forecast-accuracy"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Nehéz útvonal: 10 kérés/perc, kulccsal is.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/stations/{slug}/iceJégjelenségek az országos jelentésekből, állomásra és napra egységesítve

    Az országos jelentésekben közzétett téli jelenségek, állomásra és napra egységesítve. A mai forrás egy napi országos jelentés: az `L` oszlop ( 0–8 index ) lesz a `code`, a `phenomena` pedig a kanonikus angol kódokat tartalmazza ( `ice_floe`, `ice_bridge`, `shore_ice`… ). A 0 indexű nap valódi megfigyelés ( `ice: false`, `code: 0`, `phenomena: []` ), nem hiányzó adat. RO / BG / RS / HU nem teszi közzé a jelenséget állomásonként a napi jelentésben ( lásd a források leírását ), ezért itt nem jelennek meg.

    Paraméterek

    • slug*path
    • limitquery
    • fromquery
    • toquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/ice"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/stations/{slug}/observationsVízállás-idősor ( cm )10/min

    Nehéz végpont hosszú, névtelen történethez: 10 kérés/perc ( §3 ). Alapértelmezésben a sor az állomás **referenciaforrása** ( az országos forrás; `source` a válaszban ). A történet rétegenként épül: a `source=` egy adott forrás sorát kéri, az `include_legacy=true` pedig hozzáadja a `legacy` blokkot a legacy sorral ( más mérce: `level_cm` úgy, ahogy a forrás közzéteszi, `level_cm_aligned` a nemzeti mérce nullpontjára hozva, ha a nullpont ismert ). A sorok a `data` mezőben nem keverednek.

    Paraméterek

    • slug*path
    • sourcequery
    • include_legacyquery
    • fromquery
    • toquery
    • intervalquery
    • formatquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/observations"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Nehéz útvonal: 10 kérés/perc, kulccsal is.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/stations/{slug}/percentileA mai érték percentilise az elmúlt 30 év azonos napjához képest10/min

    Az utolsó nap vízállása ( a helyi nap első mérése, referenciaforrás ) az elmúlt 30 év azonos naptári napjához viszonyítva. A `percentile` 0…100, a `category` a very_low / low / normal / high / very_high egyike; 10 referenciaév alatt a `percentile` null. Egyetlen lekérdezés az évek ablakára, nem egy naponként.

    Paraméterek

    • slug*path
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/percentile"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Nehéz útvonal: 10 kérés/perc, kulccsal is.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/stations/{slug}/recordsTörténelmi rekordok10/min

    Paraméterek

    • slug*path
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/records"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Nehéz útvonal: 10 kérés/perc, kulccsal is.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/stations/{slug}/same-dayUgyanez a nap a korábbi években10/min

    Paraméterek

    • slug*path
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/same-day"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Nehéz útvonal: 10 kérés/perc, kulccsal is.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/stations/{slug}/winterTéli jelenségek és jégvastagság

    Az állomásra közzétett téli megfigyelések, a legújabbak elöl: a jelenség szövege és/vagy a jégvastagság cm-ben. Megfigyelések nélkül a lista üres.

    Paraméterek

    • slug*path
    • limitquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/stations/budapest/winter"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/summary/low-waterKisvíz: egymást követő napok LDC alatt, szakaszonként, előzményekkel és összevetéssel

    Hidrológiai aszály a Dunán, szakaszonként ( a folyó országai, felvíztől alvízig ): a választott évre a szakasz egy állomásának leghosszabb megszakítás nélküli LDC alatti időszaka, a rekordállomás, hány állomásnak volt kisvize, az LDC alatti állomás-napok, a szakasz előzményei és az összevetés a 2003, 2015, 2018 és 2022 referenciaévekkel. Ugyanazok a szabályok, mint a `/{lang}/statistics` „Kisvíz” lapján: a küszöböket az összesítés referenciamérése alapján ítéli meg, és egy hiányzó nap megszakítja az időszakot.

    Paraméterek

    • yearquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/summary/low-water"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/summary/todayA mai helyzet: vízállások, küszöbök, előrejelzések, a nap rendellenességei és ami ma változik a vízgyűjtőn

    A nap összesítése országonként: hány állomás van LDC alatt és HDC felett ( a küszöbökkel rendelkező állomások arányával ), hánynak nincs mérése az elmúlt 48 órában, a 24 órás tendencia ( emelkedik / csökken / stabil ) és a következő 24–72 óra előrejelzése. A D2 hozzáadja a napi normálistól való eltérést ( a D1 klimatológia ): hány állomás van p75 felett, p25 alatt vagy a normál sávban, és a legnagyobb standardizált eltérések rangsorát. Az F4 hozzáadja „ami ma változik”: az első jelentős változásokat a 24 órás ingadozásból, a Q74 hullámból ( a felvízről alvízre terjedés ideje ) és a D2 eltérésből, vízgyűjtőre ( `changes` ) és országra ( `changes_by_country` ) bontva. Ugyanazok a szabályok, mint a `/{lang}/today` oldalon: a küszöböket a friss referenciamérés alapján ítéli meg, az előrejelzés pedig egyetlen kiadásból jön.

    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/summary/today"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

Folyók és országok

  • GET/api/v1/countriesA vízgyűjtő országai
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/countries"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/riversA vízgyűjtő folyói és állomásaik száma
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/rivers"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/rivers/{rau}A folyó gráfja: torkolat, mellékfolyók, országok

    Paraméterek

    • rau*path
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/rivers/sava"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v2/countriesA vízgyűjtő országai, kurzoros lapozással ( v2 )

    A vízgyűjtő-regiszter országai, a termék nyelvein szereplő nevekkel; a kurzor az ISO-kód.

    Paraméterek

    • limitquery
    • next_cursorquery
    • fieldsquery
    • formatquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v2/countries"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v2/riversA vízgyűjtő folyói, kurzoros lapozással ( v2 )

    Az állomásregiszter folyói, az országonkénti állomásszámmal. A kurzor a folyó normalizált kódja; a `fields=` és a `format=json|csv|geojson` minden v2 listán ugyanúgy érvényes.

    Paraméterek

    • limitquery
    • next_cursorquery
    • fieldsquery
    • formatquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v2/rivers"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

Exportok

  • GET/api/v1/export/country/{cod}CSV / JSON export országonként10/min

    Paraméterek

    • cod*path
    • formatquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/export/country/HU"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Nehéz útvonal: 10 kérés/perc, kulccsal is.

    Az export is hoz `_attribution` blokkot, a licenccel az `_attribution.license` mezőben (CC BY 4.0); jelenítsd meg a `_attribution.source`, `_attribution.url` mezőt és a licencet a fájl mellett.

  • GET/api/v1/export/dailyNapi CSV / JSON export országonként10/min

    Az előző nap fájlja egy vízgyűjtői országra, CC BY 4.0 licenccel és hivatkozással. A CSV a `Link`, `X-Attribution*` és `X-License*` fejlécekbe teszi őket; a JSON az `_attribution` blokkba ( a `license` mezővel együtt ). A válasz gyorsítótárazható: `ETag`, `Last-Modified`, `Cache-Control`, és az `If-None-Match` 304-et ad vissza ugyanazokkal a fejlécekkel.

    Paraméterek

    • country*query
    • formatquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/export/daily?country=HU"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Nehéz útvonal: 10 kérés/perc, kulccsal is.

    Az export is hoz `_attribution` blokkot, a licenccel az `_attribution.license` mezőben (CC BY 4.0); jelenítsd meg a `_attribution.source`, `_attribution.url` mezőt és a licencet a fájl mellett.

  • GET/api/v1/export/rangeHosszú időszakos export kutatóknak ( CSV / Parquet, kurzoros lapozással, soronkénti licenccel )10/min

    A napi összesítés (`readings_daily`) egy oldala a `from`–`to` időszakra, csak a kifejezett újraközlési licenccel rendelkező forrásokból ( a Q90 licencregiszter ). Minden sorban ott a forrás `license` oszlopa; a teljes hivatkozás és a feltételek URL-je a `/export/range/licenses` manifesztumban és az `X-License` / `X-Attribution` / `Link` fejlécekben van. A lapozás `cursor`-ral történik ( `X-Next-Cursor`, `Link: rel="next"` ), amelyet egy ujjlenyomat köt a szűrőkhöz: két egymást követő oldal nem ismétel és nem hagy ki sorokat. Kulcs nélkül: legfeljebb 366 nap és 500 sor oldalanként; kulccsal (`Authorization: Bearer`): 20 év és 5 000 sor oldalanként. Az export nehéz végpont ( 10 kérés/perc ).

    Paraméterek

    • from*query
    • to*query
    • countryquery
    • formatquery
    • limitquery
    • cursorquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/export/range?from=2026-01-01&to=2026-10-23"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Nehéz útvonal: 10 kérés/perc, kulccsal is.

    Az export is hoz `_attribution` blokkot, a licenccel az `_attribution.license` mezőben (CC BY 4.0); jelenítsd meg a `_attribution.source`, `_attribution.url` mezőt és a licencet a fájl mellett.

  • GET/api/v1/export/range/licensesA források licencei és a hivatkozás módja az időszakos exporthoz

    A `GET /export/range` válaszában megjelenhető források manifesztuma: csak a kifejezett újraközlési licenccel rendelkezők, mindegyik az intézménnyel, a licenccel, a feltételek URL-jével, a hivatkozással, az elvégzett átalakítással ( napi összesítés ) és az ellenőrzés dátumával. Egy elutasított vagy ismeretlen forrás nem jelenik meg a manifesztumban, és nem kerül exportálásra.

    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/export/range/licenses"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    Az export is hoz `_attribution` blokkot, a licenccel az `_attribution.license` mezőben (CC BY 4.0); jelenítsd meg a `_attribution.source`, `_attribution.url` mezőt és a licencet a fájl mellett.

  • GET/api/v1/export/river/{rau}CSV / JSON export folyónként10/min

    Paraméterek

    • rau*path
    • formatquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/export/river/sava"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Nehéz útvonal: 10 kérés/perc, kulccsal is.

    Az export is hoz `_attribution` blokkot, a licenccel az `_attribution.license` mezőben (CC BY 4.0); jelenítsd meg a `_attribution.source`, `_attribution.url` mezőt és a licencet a fájl mellett.

Küszöbök, hajózás, közlemények

  • GET/api/v1/bulletinsHidrológiai jelentések országonként

    Paraméterek

    • countryquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/bulletins"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/navigationKritikus pontok és hajózási korlátozások

    Csak az aktív sorok; a lejárt korlátozások ( múltbeli `data_end` ) már nem jönnek vissza, és a korlátozások csak a megőrzött hivatalos forrásokból származnak. A válasz rkm szerint rendezett.

    Paraméterek

    • riverquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/navigation"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/thresholdsHivatalos küszöbök ( LDC/HDC, RNW/HSW, árvízvédelmi fokozatok )

    Csak az aktív küszöbök ( az archivált értékek `activ: false` jelöléssel a platformon maradnak, és nem jelennek meg ). A `station` az állomás slugja; egy ismeretlen slug 404-et ad.

    Paraméterek

    • stationquery
    • pagequery
    • limitquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/thresholds"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v2/bulletinsHidrológiai jelentések, kurzoros lapozással ( v2 )

    Az országos jelentések, a legújabbak elöl; a `country` szűr, a kurzor a jelentés azonosítója.

    Paraméterek

    • countryquery
    • limitquery
    • next_cursorquery
    • fieldsquery
    • formatquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v2/bulletins"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v2/navigationHajózás, egyetlen lapozott lista ( v2 )

    A kritikus pontok és az aktív korlátozások egyetlen listában, soronként a `kind` mezővel ( `punct_critic` vagy `restrictie` ); a kurzor a `kind:id` összetétel. Geometria a pontoknál van.

    Paraméterek

    • riverquery
    • limitquery
    • next_cursorquery
    • fieldsquery
    • formatquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v2/navigation"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v2/thresholdsHivatalos küszöbök, kurzoros lapozással ( v2 )

    Az aktív küszöbök, a `station` ( slug ) szűrővel; a kurzor a küszöb azonosítója. Egy ismeretlen slug 404-et ad, mint a v1-ben.

    Paraméterek

    • stationquery
    • limitquery
    • next_cursorquery
    • fieldsquery
    • formatquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v2/thresholds"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

Riasztási epizódok

  • GET/api/v1/episodesNyilvános LDC/HDC epizódok

    Paraméterek

    • countryquery
    • typequery
    • limitquery
    • next_cursorquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/episodes"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/episodes/{id}Egy riasztási epizód

    Paraméterek

    • id*path
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/episodes/1"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

GeoJSON

  • GET/api/v1/geojson/riversA Duna hajózható vonala + Száva / Tisza
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/geojson/rivers"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/geojson/stationsAz állomások FeatureCollection-je

    Paraméterek

    • countryquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/geojson/stations"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

Források és adatminőség

  • GET/api/v1/meta/availabilityA források havi elérhetősége ( 12 hónap ): adatos napok és a legutóbbi futások

    A nyilvános „adatátláthatóság” jelentés: forrásonként egy hónap az utolsó 12 naptári hónapra, a számított napokkal (`days`, az aktuális hónap csak tegnapig), a legalább egy méréssel rendelkező napokkal (`days_with_data`) és azok százalékával. A `last_7_days` az utolsó 7 nap futásait és hibáit adja a Q62 naplóból (`runs` / `failures`; `null` = nincs napló). Csak számok: nincs hibaüzenet, nincs URL, nincs állomásadat. Napi összesítés nélkül ( ingest nélküli példány ) a `sources` üres, nem „0 %”.

    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/meta/availability"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/meta/healthA források állapota
    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/meta/health"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/meta/qualityAdatminőség állomásonként: gyanús mérések és a forrás állapota

    Állomásonkénti összesítés: a gyanús mérések száma ( a szomszédok mediánjától ±6 h-n belül mért küszöböt meghaladó eltérés ), az utolsó mérés és az azt hozó forrás állapota ( `source_state`: `ok`, `eroare`, `stale` — „nincs mérés határidőn belül” ).

    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/meta/quality"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v1/meta/sourcesAz utolsó frissítés forrásonként

    Soronként egy crawl-forrás: az utolsó sikeres futás, annak állapota, az SLA, **az utolsó írás**, **az elmúlt 24 órában olvasott sorok és írt mérések**, **a 7 és 30 napos uptime**, **az átlagos késés** ( a legfrissebb mérés átlagos kora 7 napon át ) és **az utolsó hiba** ( a forrás visszatérése után is megőrizve ). A `stare` akkor lehet `cazuta`, ha a forrás több mint 2 × intervallumnyi ideje nem írt semmit, az `eroare` pedig azt jelenti, hogy az utolsó futás meghiúsult **és** az előtte lévő adatok kikerültek a forrás SLA-jából; egy hálózati kiesés, amíg az adatok még határidőn belül vannak, változatlanul hagyja a `stare` mezőt ( a hiba az `ultima_eroare` mezőben marad ). Az `uptime_7d` / `uptime_30d` 0–1 közötti tört; a `null` = az ablak nem számítható ki, vagy a `readings` most nem érhető el, nem „tökéletes forrás”.

    curl
    curl -sS "https://danubealert.arcm.ro/api/v1/meta/sources"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

  • GET/api/v2/meta/sourcesAdatforrások, kurzoros lapozással ( v2 )

    Az utolsó futás és az időbeli minőség forrásonként; a kurzor a forrás kódja. A mezők ugyanazok, mint a `/v1/meta/sources` válaszában.

    Paraméterek

    • limitquery
    • next_cursorquery
    • fieldsquery
    • formatquery
    curl
    curl -sS "https://danubealert.arcm.ro/api/v2/meta/sources"
    JavaScript
    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)
    Python
    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"])

    Kéréskorlát: Névtelen: 60 kérés/perc (csúszóablak); `Authorization: Bearer <kulcs>` fejléccel: 600/perc.

    A válasz `_attribution` blokkot hoz; jelenítsd meg az `_attribution.source` és `_attribution.url` mezőt az adatok mellett.

Kéréskorlátok

Csúszó, 60 másodperces ablak; a mérési idősor nehéz végpont (percenként 10). A korlát felett: 429, a törzsben retry_after_seconds, a fejlécekben Retry-After és X-RateLimit-*. Az elutasított kérések nem terhelik a következő ablakot.

Kéréskorlátok
FejlécJelentés
X-RateLimit-Limit60 / 600 / 3000 / 10
X-RateLimit-Remaining0 … limit
Retry-Afters ( 429 )
429 · retry_after_secondsJSON

Típusos TypeScript-kliens

Közvetlenül a szerződésből generált típusok — minden útvonal, paraméter és válasz, kézzel írt modellek nélkül.

TypeScript
npx openapi-typescript https://danubealert.arcm.ro/api/v1/openapi.hu.json -o danubealert.d.ts

import type { paths } from './danubealert'
type Observatii = paths['/stations/{slug}/observations']['get']['responses']['200']['content']['application/json']

Nyílt adatok exportja

Az előző nap fájljai, állomásonként egy sor, a vízgyűjtő minden országára, CSV vagy JSON formátumban. A válaszok gyorsítótárazhatók (ETag, Last-Modified, Cache-Control); a licenc és a forrásmegjelölés a fájl fejlécében és a JSON _attribution blokkjában található.

Licenc: Creative Commons Attribution 4.0 International · Forrásmegjelölés: DanubeAlert és a nemzeti hidrológiai szolgálatok · Az előző nap, az ország időzónájában.

Widget-konfigurátor

Egy állomás vízállása a saját oldaladon: válaszd ki az állomást, a témát, a nyelvet és az arculatot, nézd meg élőben a widgetet, és másold az iframe-kódot bármely CMS-be.

A widgeteid három lépésben

Válaszd ki a típust és a beállításokat — az előnézet és a kód azonnal frissül.

Téma
Méret

Előnézet ( bélyegkép )

Beillesztendő kód

<iframe
  src="https://danubealert.arcm.ro/embed/v1/station?slug=achleiten&theme=auto&lang=hu&accent=00BABE"
  title="Danube water level — Achleiten"
  width="100%"
  height="300"
  style="border:0;max-width:640px;"
  loading="lazy"
  referrerpolicy="strict-origin-when-cross-origin"
></iframe>

A teljes szerződés: /api/v1/openapi.hu.json · /api/v1/openapi.json · Adatok: a nemzeti hidrológiai szolgálatok, a DanubeAlerten keresztül